@sonordev/site-kit 8.5.2 → 8.7.0

package/dist/chunk-FXR5PJDL.js

@@ -0,0 +1,420 @@
+import { LandingPage } from './chunk-PAYCK7FC.js';
+import { normalizeCampaignSlug } from './chunk-3MJNBOUO.js';
+import { landingPageMetadata } from './chunk-JESLPEST.js';
+import { ServerForm } from './chunk-DPYGC7WE.js';
+import { serverApiFetch } from './chunk-C7TLGL3R.js';
+import { normalizeSiteHost } from './chunk-A4CC4ZG3.js';
+import 'server-only';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+
+// src/contracts/public-url-host.ts
+function isPrivateIpv4(a, b) {
+  return a === 127 || a === 10 || a === 0 || a === 192 && b === 168 || a === 172 && b >= 16 && b <= 31 || a === 169 && b === 254 || a === 100 && b >= 64 && b <= 127 || a >= 224;
+}
+function ipv6Words(host) {
+  if (!host.includes(":") || !/^[a-f\d:.]+$/.test(host)) return null;
+  let canonical;
+  try {
+    canonical = new URL(`http://[${host}]/`).hostname.slice(1, -1);
+  } catch {
+    return null;
+  }
+  const sides = canonical.split("::");
+  const left = sides[0] ? sides[0].split(":") : [];
+  const right = sides.length > 1 && sides[1] ? sides[1].split(":") : [];
+  return [...left, ...Array(sides.length > 1 ? 8 - left.length - right.length : 0).fill("0"), ...right].map((word) => parseInt(word, 16));
+}
+function isBlockedPublicUrlHost(rawHost) {
+  const host = rawHost.toLowerCase().replace(/^\[|\]$/g, "");
+  const blockedName = host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal");
+  if (host.includes(":") && host.includes("%")) return true;
+  const ipv4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
+  const blockedIp = !!ipv4 && isPrivateIpv4(Number(ipv4[1]), Number(ipv4[2]));
+  const words = ipv6Words(host);
+  const blockedIpv6 = !!words && // Unspecified/loopback, unique-local, link-local, deprecated site-local
+  // and multicast destinations aren't public logo/webhook endpoints.
+  (words.every((word) => word === 0) || words.slice(0, 7).every((word) => word === 0) && words[7] === 1 || (words[0] & 65024) === 64512 || (words[0] & 65472) === 65152 || (words[0] & 65472) === 65216 || (words[0] & 65280) === 65280 || // IPv4-mapped and older IPv4-compatible forms carry an IPv4 destination.
+  words.slice(0, 5).every((word) => word === 0) && [0, 65535].includes(words[5]) && isPrivateIpv4(words[6] >> 8, words[6] & 255));
+  return blockedName || blockedIp || blockedIpv6;
+}
+
+// src/contracts/publication-branding.ts
+var PUBLICATION_COLOR_FIELDS = ["primary", "secondary", "accent", "background", "surface", "text", "muted", "border"];
+var GENERIC_FONT_FAMILIES = /* @__PURE__ */ new Set(["serif", "sans-serif", "monospace", "system-ui", "cursive", "fantasy", "ui-serif", "ui-sans-serif", "ui-monospace"]);
+function containsControlCharacters(value) {
+  for (const character of value) {
+    const code = character.charCodeAt(0);
+    if (code <= 31 || code === 127) return true;
+  }
+  return false;
+}
+function safeFontStack(value) {
+  if (typeof value !== "string" || value.length > 512 || containsControlCharacters(value) || /[;{}<>\\]|(?:var|url|expression)\s*\(/i.test(value)) return void 0;
+  const names = value.split(",").map((v) => v.trim().replace(/^(['"])(.*)\1$/, "$2")).filter(Boolean).filter((v) => !/^(?:heading|body|mono)$/i.test(v));
+  if (!names.length || names.some((v) => !/^[\p{L}\p{N} _.-]+$/u.test(v))) return void 0;
+  return names.map((v) => GENERIC_FONT_FAMILIES.has(v.toLowerCase()) ? v.toLowerCase() : `'${v}'`).join(",");
+}
+
+// src/contracts/funnels.ts
+var MANAGED_FUNNEL_PATH_PREFIX = "/f";
+var FUNNEL_TEMPLATES = ["newsletter", "requested_guide", "inquiry"];
+var string = (maxLength, minLength = 1) => ({ type: "string", minLength, maxLength });
+var literal = (value) => ({ const: value });
+var enumeration = (...values) => ({ type: "string", enum: values });
+var object = (properties, required = Object.keys(properties)) => ({ type: "object", properties, required, additionalProperties: false });
+var array = (items, maxItems, minItems = 0) => ({ type: "array", items, maxItems, minItems });
+var integer = (minimum, maximum = Number.MAX_SAFE_INTEGER) => ({ type: "integer", minimum, maximum });
+var nullable = (shape) => ({ oneOf: [shape, { type: "null" }] });
+var isoDate = { type: "string", pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,3})?Z$" };
+var uuid = { type: "string", pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$" };
+var slug = { ...string(80), pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*$" };
+var fieldSlug = { ...string(80), pattern: "^[a-zA-Z0-9_-]+$" };
+var path = { ...string(512), pattern: "^/(?!/)[a-zA-Z0-9/_-]*$" };
+var site = { ...string(253), pattern: "^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+$" };
+var color = { ...string(9), pattern: "^#[a-fA-F0-9]{6}$" };
+var colors = object(Object.fromEntries(PUBLICATION_COLOR_FIELDS.map((key) => [key, color])));
+var typography = object({ headingFamily: string(200), bodyFamily: string(200) });
+var override = object({
+  displayName: nullable(string(120)),
+  tagline: nullable(string(300, 0)),
+  fullLogoAssetId: nullable(uuid),
+  squareLogoAssetId: nullable(uuid),
+  colors: object(Object.fromEntries(PUBLICATION_COLOR_FIELDS.map((key) => [key, nullable(color)])), []),
+  typography: object({ headingFamily: nullable(string(200)), bodyFamily: nullable(string(200)) }, [])
+}, []);
+var bodyBlock = { oneOf: [object({ type: literal("paragraph"), text: string(2e3) }), object({ type: literal("bullets"), items: array(string(500), 8, 1) })] };
+var body = array(bodyBlock, 12);
+var publicBrand = object({ displayName: string(120), tagline: string(300, 0), fullLogoUrl: nullable(string(2048)), squareLogoUrl: nullable(string(2048)), colors, typography, scheme: enumeration("light", "dark") });
+var step = { oneOf: [
+  object({ id: uuid, type: literal("wait"), durationSeconds: integer(60, 2592e3) }),
+  object({ id: uuid, type: literal("send_email"), templateId: uuid, purpose: enumeration("requested_fulfillment", "marketing"), guideAssetId: nullable(uuid) }, ["id", "type", "templateId", "purpose"]),
+  object({ id: uuid, type: literal("add_tag"), target: literal("subscriber"), tag: string(80) }),
+  object({ id: uuid, type: literal("create_task"), ownerContactId: uuid, title: string(160), dueAfterSeconds: integer(0, 2592e3) })
+] };
+var definitionShape = object({
+  schemaVersion: literal(1),
+  name: string(120),
+  template: enumeration(...FUNNEL_TEMPLATES),
+  site,
+  entry: object({ formId: uuid, mode: literal("future_accepted_form_only") }),
+  goal: object({ type: enumeration("newsletter_confirmed", "guide_requested", "inquiry_received", "booking_confirmed"), bookingTypeId: nullable(uuid) }, ["type"]),
+  page: object({ mode: enumeration("existing", "managed"), path, slug: nullable(slug), headline: string(160, 0), body, formId: uuid, offerAssetId: nullable(uuid) }, ["mode", "path", "headline", "body", "formId"]),
+  permission: object({ mode: enumeration("requested_only", "marketing_opt_in"), optInFieldSlug: nullable(fieldSlug) }, ["mode"]),
+  brandOverride: override,
+  steps: array(step, 8),
+  exits: object({ unsubscribe: literal(true), manualStop: literal(true), confirmedBooking: object({ enabled: { type: "boolean" }, bookingTypeId: nullable(uuid) }) }, ["unsubscribe", "manualStop"])
+}, ["schemaVersion", "name", "template", "site", "entry", "goal", "page", "permission", "steps", "exits"]);
+var draftDefinitionShape = JSON.parse(JSON.stringify(definitionShape));
+var draftProps = draftDefinitionShape.properties;
+draftProps.name = string(120, 0);
+draftProps.site = nullable(site);
+draftProps.entry.properties.formId = nullable(uuid);
+draftProps.page.properties.path = nullable(path);
+draftProps.page.properties.formId = nullable(uuid);
+draftProps.permission.properties.optInFieldSlug = nullable(fieldSlug);
+draftProps.steps.items.oneOf = draftProps.steps.items.oneOf.map((item) => {
+  const fields = item.properties;
+  if (fields.templateId) fields.templateId = nullable(uuid);
+  if (fields.guideAssetId) fields.guideAssetId = nullable(uuid);
+  if (fields.ownerContactId) fields.ownerContactId = nullable(uuid);
+  if (fields.title) fields.title = string(160, 0);
+  if (fields.tag) fields.tag = string(80, 0);
+  return item;
+});
+draftProps.page.properties.body = array({ oneOf: [object({ type: literal("paragraph"), text: string(2e3, 0) }), object({ type: literal("bullets"), items: array(string(500, 0), 8, 1) })] }, 12);
+var FUNNEL_DRAFT_DEFINITION_JSON_SCHEMA = { $schema: "http://json-schema.org/draft-07/schema#", ...draftDefinitionShape };
+var FUNNEL_DEFINITION_JSON_SCHEMA = { $schema: "http://json-schema.org/draft-07/schema#", ...definitionShape };
+var publishedShape = object({
+  schemaVersion: literal(1),
+  id: uuid,
+  versionId: uuid,
+  revision: integer(1),
+  site,
+  path,
+  content: object({ headline: string(160), body, offer: object({ label: string(120), href: string(2048) }) }, ["headline", "body"]),
+  brand: publicBrand,
+  conversion: object({ formSlug: fieldSlug }),
+  tracking: object({ campaignSlug: slug })
+});
+var PUBLISHED_FUNNEL_PAGE_JSON_SCHEMA = { $schema: "http://json-schema.org/draft-07/schema#", ...publishedShape };
+var FUNNEL_LAUNCH_JSON_SCHEMA = object({ expectedRevision: integer(1), previewId: uuid, idempotencyKey: string(200), confirm: literal(true) });
+var FUNNEL_LIFECYCLE_JSON_SCHEMA = object({ expectedActiveVersionId: uuid, idempotencyKey: string(200), confirm: literal(true) });
+var FUNNEL_ROLLBACK_JSON_SCHEMA = object({ expectedActiveVersionId: uuid, targetVersionId: uuid, idempotencyKey: string(200), confirm: literal(true) });
+var FunnelValidationError = class extends Error {
+  constructor(path2, reason) {
+    super(`${path2}: ${reason}`);
+    this.path = path2;
+    this.name = "FunnelValidationError";
+  }
+};
+function fail(path2, reason) {
+  throw new FunnelValidationError(path2, reason);
+}
+function check(value, shape, at) {
+  if (shape.oneOf) {
+    let matches = 0;
+    for (const candidate of shape.oneOf) {
+      try {
+        check(value, candidate, at);
+        matches++;
+      } catch (error) {
+        if (!(error instanceof FunnelValidationError)) throw error;
+      }
+    }
+    if (matches !== 1) fail(at, "must match one supported shape");
+    return;
+  }
+  if ("const" in shape && value !== shape.const) fail(at, "unexpected value");
+  if (shape.enum && !shape.enum.includes(value)) fail(at, "unsupported value");
+  if (shape.type === "null" && value !== null) fail(at, "must be null");
+  if (shape.type === "boolean" && typeof value !== "boolean") fail(at, "must be boolean");
+  if (shape.type === "string") {
+    if (typeof value !== "string") fail(at, "must be a string");
+    if (value.length < (shape.minLength ?? 0) || value.length > (shape.maxLength ?? Infinity) || (shape.minLength ?? 0) > 0 && !value.trim() || /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(value)) fail(at, "invalid string length or control character");
+    if (shape.pattern) {
+      const match = new RegExp(shape.pattern).exec(value);
+      if (!match || match[0] !== value) fail(at, "invalid format");
+    }
+  }
+  if (shape.type === "integer" && (typeof value !== "number" || !Number.isSafeInteger(value) || value < (shape.minimum ?? -Infinity) || value > (shape.maximum ?? Infinity))) fail(at, "invalid integer");
+  if (shape.type === "array") {
+    if (!Array.isArray(value) || value.length < (shape.minItems ?? 0) || value.length > (shape.maxItems ?? Infinity)) fail(at, "invalid array length");
+    value.forEach((item, i) => check(item, shape.items, `${at}[${i}]`));
+  }
+  if (shape.type === "object") {
+    if (!value || typeof value !== "object" || Array.isArray(value)) fail(at, "must be an object");
+    const row = value;
+    if (![Object.prototype, null].includes(Object.getPrototypeOf(row))) fail(at, "must be plain JSON");
+    for (const key of shape.required ?? []) if (!Object.prototype.hasOwnProperty.call(row, key)) fail(`${at}.${key}`, "required");
+    for (const key of Object.keys(row)) {
+      if (!Object.prototype.hasOwnProperty.call(shape.properties, key)) fail(`${at}.${key}`, "unknown field");
+      check(row[key], shape.properties[key], `${at}.${key}`);
+    }
+  }
+}
+function isSafeFunnelPublicUrl(value) {
+  try {
+    const url = new URL(value);
+    return value.startsWith("https://") && url.protocol === "https:" && !url.username && !url.password && (!url.port || url.port === "443") && !isBlockedPublicUrlHost(url.hostname) && !/[\s\x00-\x1f\\]/.test(value);
+  } catch {
+    return false;
+  }
+}
+function managedFunnelPath(value) {
+  check(value, slug, "slug");
+  if (normalizeCampaignSlug(value) !== value) fail("slug", "must be canonical");
+  return `${MANAGED_FUNNEL_PATH_PREFIX}/${value}`;
+}
+function checkFonts(value, at) {
+  for (const [key, font] of Object.entries(value.typography ?? {})) if (font !== null && safeFontStack(font) === void 0) fail(`${at}.typography.${key}`, "unsafe font stack");
+}
+function checkBody(blocks, at) {
+  if (blocks.reduce((total, block) => total + (block.type === "paragraph" ? block.text.length : block.items.join("").length), 0) > 12e3) fail(at, "total text exceeds 12000 characters");
+}
+function parsePublishedFunnelPage(value) {
+  check(value, publishedShape, "page");
+  const result = JSON.parse(JSON.stringify(value));
+  const suffix = result.path.slice(MANAGED_FUNNEL_PATH_PREFIX.length + 1);
+  if (managedFunnelPath(suffix) !== result.path) fail("page.path", "invalid managed route");
+  for (const key of ["fullLogoUrl", "squareLogoUrl"]) if (result.brand[key] && !isSafeFunnelPublicUrl(result.brand[key])) fail(`page.brand.${key}`, "unsafe public URL");
+  checkFonts(result.brand, "page.brand");
+  checkBody(result.content.body, "page.content.body");
+  if (result.content.offer && !isSafeFunnelPublicUrl(result.content.offer.href)) fail("page.content.offer.href", "unsafe public URL");
+  return result;
+}
+var FUNNEL_CREATE_JSON_SCHEMA = object({ idempotencyKey: string(200), definition: draftDefinitionShape });
+var FUNNEL_UPDATE_JSON_SCHEMA = object({ expectedRevision: integer(1), idempotencyKey: string(200), definition: draftDefinitionShape });
+var FUNNEL_REVISION_JSON_SCHEMA = object({ expectedRevision: integer(1) });
+var FUNNEL_RETRY_JSON_SCHEMA = object({ expectedAttempt: integer(0, 100), idempotencyKey: string(200), confirm: literal(true) });
+var FUNNEL_DRAFT_JSON_SCHEMAS = { create: FUNNEL_CREATE_JSON_SCHEMA, update: FUNNEL_UPDATE_JSON_SCHEMA };
+var fingerprint = { type: "string", pattern: "^[a-f0-9]{64}$" };
+var issue = object({ code: { ...string(80), pattern: "^[A-Z][A-Z0-9_]*$" }, path: string(300), message: string(500), fixRef: object({ section: string(80), field: string(80), resourceId: uuid }, ["section"]) }, ["code", "path", "message"]);
+var FUNNEL_READINESS_JSON_SCHEMA = object({ definitionRevision: integer(1), brandFingerprint: fingerprint, resourceFingerprint: fingerprint, ready: { type: "boolean" }, blockers: array(issue, 50), warnings: array(issue, 50), capabilities: object({ managedPage: { type: "boolean" } }) });
+var funnelDetailShape = object({ id: uuid, revision: integer(1), definition: draftDefinitionShape, activeVersionId: nullable(uuid), lifecycle: enumeration("draft", "active", "paused"), health: enumeration("healthy", "waiting", "needs_attention", "unknown"), hasDraftChanges: { type: "boolean" }, readiness: FUNNEL_READINESS_JSON_SCHEMA });
+var FUNNEL_DETAIL_JSON_SCHEMA = funnelDetailShape;
+var FUNNEL_OPERATION_RECEIPT_JSON_SCHEMA = object({
+  operationId: uuid,
+  projectId: uuid,
+  orgId: uuid,
+  funnelId: uuid,
+  operation: enumeration("create", "update", "launch", "pause", "resume", "retry", "rollback"),
+  idempotencyKey: string(200),
+  requestDigest: fingerprint,
+  versionId: nullable(uuid),
+  lifecycle: enumeration("draft", "active", "paused"),
+  replayed: { type: "boolean" },
+  armedFutureEntrantsOnly: literal(true),
+  enrolledExisting: literal(0),
+  messagesSent: literal(0),
+  pagePublication: enumeration("not_requested", "published", "revalidation_pending"),
+  health: enumeration("healthy", "waiting", "needs_attention", "unknown"),
+  revision: integer(1),
+  commandState: literal("committed"),
+  funnel: nullable(funnelDetailShape),
+  actor: string(200),
+  armedAt: nullable(isoDate),
+  effectScope: enumeration("configuration_only", "safe_retry_armed"),
+  target: object({ funnelId: nullable(uuid), enrollmentId: nullable(uuid), executionId: nullable(uuid), targetVersionId: nullable(uuid) }),
+  ledgerProposalId: uuid
+});
+var provenancePaths = ["displayName", "tagline", "fullLogoUrl", "squareLogoUrl", "scheme", ...PUBLICATION_COLOR_FIELDS.map((key) => `colors.${key}`), "typography.headingFamily", "typography.bodyFamily"];
+var brandSnapshotShape = object({
+  page: publicBrand,
+  email: publicBrand,
+  provenance: object(Object.fromEntries(["page", "email"].flatMap((channel) => provenancePaths.map((key) => [`${channel}.${key}`, enumeration("project", "brand_profile", "site_design", "publication_branding", "platforms.publication", "platforms.email", "funnel_override", "default")]))), []),
+  assetRefs: array(object({ id: nullable(uuid), version: nullable(string(128)) }), 32),
+  capturedAt: isoDate,
+  fingerprint
+});
+var FUNNEL_BRAND_SNAPSHOT_JSON_SCHEMA = brandSnapshotShape;
+var choicePage = (item) => object({ items: array(item, 100), nextCursor: nullable(string(500)) });
+var choiceFields = { id: uuid, label: string(120) };
+var catalogShape = object({
+  templates: array(object({ id: enumeration(...FUNNEL_TEMPLATES), label: string(120), defaults: draftDefinitionShape }), 3),
+  sites: array(object({ host: site, label: string(200) }), 200),
+  brand: nullable(brandSnapshotShape),
+  choices: object({
+    forms: choicePage(object({ ...choiceFields, slug: string(120), site: nullable(site), formType: enumeration("prospect", "contact", "support", "feedback", "newsletter", "custom"), active: { type: "boolean" }, newsletterListIds: array(uuid, 20), fields: array(object({ slug: fieldSlug, type: string(80), label: string(120), required: { type: "boolean" } }), 100) })),
+    lists: choicePage(object({ ...choiceFields, active: { type: "boolean" }, doubleOptIn: { type: "boolean" } })),
+    emailTemplates: choicePage(object({ ...choiceFields, subject: string(998, 0), updatedAt: nullable(isoDate) })),
+    assets: choicePage(object({ ...choiceFields, label: string(160), mimeType: string(100), sizeBytes: integer(0, 52428800), visibility: literal("public"), publicUrl: string(2048), version: nullable(string(200)) })),
+    owners: choicePage(object({ ...choiceFields, active: literal(true) })),
+    bookingTypes: choicePage(object({ ...choiceFields, site: nullable(site), active: literal(true), requiresConfirmation: { type: "boolean" } }))
+  }, []),
+  capabilities: object({ managedPage: { type: "boolean" } })
+});
+var FUNNEL_CATALOG_JSON_SCHEMA = catalogShape;
+var launchEvidenceShape = object({ projectId: uuid, orgId: uuid, funnelId: uuid, previewId: uuid, versionId: uuid, definitionRevision: integer(1), definitionDigest: fingerprint, brandFingerprint: fingerprint, resourceFingerprint: fingerprint, entryDigest: fingerprint, permissionDigest: fingerprint, expiresAt: isoDate });
+var FUNNEL_LAUNCH_EVIDENCE_JSON_SCHEMA = launchEvidenceShape;
+var FUNNEL_ROLLBACK_EVIDENCE_JSON_SCHEMA = object({ orgId: uuid, projectId: uuid, funnelId: uuid, targetVersionId: uuid, definitionRevision: integer(1), definitionDigest: fingerprint, brandFingerprint: fingerprint, resourceFingerprint: fingerprint });
+var FUNNEL_PREVIEW_JSON_SCHEMA = object({
+  previewId: uuid,
+  versionId: uuid,
+  expiresAt: isoDate,
+  definitionRevision: integer(1),
+  brand: brandSnapshotShape,
+  readiness: FUNNEL_READINESS_JSON_SCHEMA,
+  page: nullable(publishedShape),
+  launchEvidence: launchEvidenceShape,
+  emailPreviews: array(object({ stepId: uuid, ready: { type: "boolean" }, subject: nullable(string(998, 0)), contentHtml: nullable(string(2e5, 0)), issues: array(issue, 50) }), 8)
+});
+var summaryShape = object({
+  id: uuid,
+  name: string(120, 0),
+  template: enumeration(...FUNNEL_TEMPLATES),
+  site: nullable(site),
+  revision: integer(1),
+  activeVersionId: nullable(uuid),
+  lifecycle: enumeration("draft", "active", "paused"),
+  health: enumeration("healthy", "waiting", "needs_attention", "unknown"),
+  hasDraftChanges: { type: "boolean" },
+  counts: object({ entered: integer(0), waiting: integer(0), running: integer(0), completed: integer(0), exited: integer(0), needsAttention: integer(0) }),
+  countsBasis: literal("all_versions_all_time"),
+  lastEventAt: nullable(isoDate)
+});
+var FUNNEL_SUMMARY_JSON_SCHEMA = summaryShape;
+var FUNNEL_ENROLLMENT_JSON_SCHEMA = object({
+  id: uuid,
+  versionId: uuid,
+  state: enumeration("waiting", "running", "completed", "exited", "needs_attention"),
+  effectiveStatus: enumeration("paused", "waiting", "running", "completed", "exited", "needs_attention"),
+  source: object({ submissionId: uuid, acceptedAt: isoDate }),
+  subject: object({ kind: enumeration("subscriber", "contact", "submission"), id: uuid, displayLabel: string(200) }),
+  enteredAt: isoDate,
+  nextRunAt: nullable(isoDate),
+  exitCode: nullable(string(80)),
+  stepsCompleted: integer(0, 8),
+  stepsTotal: integer(0, 8),
+  lastReceiptAt: nullable(isoDate)
+});
+var FUNNEL_TIMELINE_JSON_SCHEMA = object({
+  items: array(object({ executionId: uuid, stepId: uuid, type: enumeration("wait", "send_email", "add_tag", "create_task"), state: enumeration("pending", "claimed", "queued", "admitted", "succeeded", "skipped", "uncertain", "failed"), dueAt: nullable(isoDate), occurredAt: nullable(isoDate), attempt: integer(0, 100), reasonCode: nullable(string(80)), message: string(500, 0), receipt: nullable(object({ domain: enumeration("campaign_send", "subscriber_tag", "crm_task", "wait"), id: nullable(uuid), state: string(80) })), canRetry: { type: "boolean" } }), 100),
+  nextCursor: nullable(string(500)),
+  exit: nullable(object({ code: string(80), sourceType: string(80), sourceId: nullable(uuid), occurredAt: isoDate }))
+});
+function freezeSchema(value) {
+  if (!value || typeof value !== "object" || Object.isFrozen(value)) return;
+  for (const child of Object.values(value)) freezeSchema(child);
+  Object.freeze(value);
+}
+for (const schema of [FUNNEL_DEFINITION_JSON_SCHEMA, FUNNEL_DRAFT_DEFINITION_JSON_SCHEMA, PUBLISHED_FUNNEL_PAGE_JSON_SCHEMA, FUNNEL_LAUNCH_JSON_SCHEMA, FUNNEL_LIFECYCLE_JSON_SCHEMA, FUNNEL_ROLLBACK_JSON_SCHEMA, FUNNEL_CREATE_JSON_SCHEMA, FUNNEL_UPDATE_JSON_SCHEMA, FUNNEL_REVISION_JSON_SCHEMA, FUNNEL_RETRY_JSON_SCHEMA, FUNNEL_DRAFT_JSON_SCHEMAS, FUNNEL_READINESS_JSON_SCHEMA, FUNNEL_DETAIL_JSON_SCHEMA, FUNNEL_OPERATION_RECEIPT_JSON_SCHEMA, FUNNEL_BRAND_SNAPSHOT_JSON_SCHEMA, FUNNEL_CATALOG_JSON_SCHEMA, FUNNEL_PREVIEW_JSON_SCHEMA, FUNNEL_SUMMARY_JSON_SCHEMA, FUNNEL_ENROLLMENT_JSON_SCHEMA, FUNNEL_TIMELINE_JSON_SCHEMA]) freezeSchema(schema);
+var FUNNEL_VERSION_JSON_SCHEMA = object({ versionId: uuid, definitionRevision: integer(1), publishedAt: isoDate, brandFingerprint: fingerprint, resourceFingerprint: fingerprint, active: { type: "boolean" } });
+var FUNNEL_VERSION_DETAIL_JSON_SCHEMA = object({ ...FUNNEL_VERSION_JSON_SCHEMA.properties, rollbackEvidence: FUNNEL_ROLLBACK_EVIDENCE_JSON_SCHEMA });
+for (const schema of [FUNNEL_LAUNCH_EVIDENCE_JSON_SCHEMA, FUNNEL_ROLLBACK_EVIDENCE_JSON_SCHEMA, FUNNEL_VERSION_JSON_SCHEMA, FUNNEL_VERSION_DETAIL_JSON_SCHEMA]) freezeSchema(schema);
+function FunnelPageContent({ page: input, conversion, preview = false }) {
+  const page = parsePublishedFunnelPage(input);
+  const { brand, content } = page;
+  const tokens = {
+    "--sk-primary": brand.colors.primary,
+    "--sk-secondary": brand.colors.secondary,
+    "--sk-bg": brand.colors.background,
+    "--sk-surface": brand.colors.surface,
+    "--sk-text-primary": brand.colors.text,
+    "--sk-text-secondary": brand.colors.muted,
+    "--sk-border": brand.colors.border,
+    "--sk-font": brand.typography.bodyFamily,
+    colorScheme: brand.scheme,
+    color: "var(--sk-text-primary)",
+    background: "var(--sk-bg)",
+    fontFamily: "var(--sk-font)",
+    overflowWrap: "anywhere"
+  };
+  return /* @__PURE__ */ jsxs("article", { className: "sk-funnel", style: tokens, "data-sk-private-preview": preview ? "" : void 0, "data-sk-funnel-revision": page.revision, children: [
+    preview && /* @__PURE__ */ jsx("meta", { name: "robots", content: "noindex, nofollow" }),
+    /* @__PURE__ */ jsx("style", { children: `.sk-funnel{padding:clamp(1rem,5vw,4rem);line-height:1.65}.sk-funnel-inner{max-width:68rem;margin-inline:auto}.sk-funnel-brand{display:flex;align-items:center;gap:1rem;margin-bottom:2rem}.sk-funnel-brand img{max-width:min(16rem,60vw);height:auto;max-height:5rem;object-fit:contain}.sk-funnel-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(min(100%,24rem),1fr));gap:clamp(1.5rem,5vw,4rem);align-items:start}.sk-funnel h1{font-size:clamp(2rem,5vw,3.5rem);line-height:1.12;margin:0 0 1.5rem}.sk-funnel p,.sk-funnel li{max-width:65ch}.sk-funnel-conversion{padding:clamp(1rem,3vw,2rem);border:1px solid var(--sk-border);border-radius:var(--sk-radius-lg);background:var(--sk-surface)}.sk-funnel a{color:var(--sk-primary);text-decoration:underline}.sk-funnel a:focus-visible{outline:3px solid var(--sk-primary);outline-offset:4px}.sk-funnel-preview{font-weight:600}.sk-funnel ul{padding-inline-start:1.25rem}` }),
+    /* @__PURE__ */ jsxs("div", { className: "sk-funnel-inner", children: [
+      /* @__PURE__ */ jsxs("header", { className: "sk-funnel-brand", children: [
+        brand.fullLogoUrl && /* @__PURE__ */ jsx("img", { src: brand.fullLogoUrl, alt: brand.displayName, width: 256, height: 80, fetchPriority: "high" }),
+        /* @__PURE__ */ jsxs("div", { children: [
+          !brand.fullLogoUrl && /* @__PURE__ */ jsx("strong", { children: brand.displayName }),
+          brand.tagline && /* @__PURE__ */ jsx("p", { children: brand.tagline })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "sk-funnel-grid", children: [
+        /* @__PURE__ */ jsxs("section", { "aria-label": content.headline, children: [
+          /* @__PURE__ */ jsx("h1", { style: { fontFamily: brand.typography.headingFamily }, children: content.headline }),
+          content.body.map((block, index) => block.type === "paragraph" ? /* @__PURE__ */ jsx("p", { children: block.text }, index) : /* @__PURE__ */ jsx("ul", { children: block.items.map((item, i) => /* @__PURE__ */ jsx("li", { children: item }, i)) }, index)),
+          content.offer && (preview ? /* @__PURE__ */ jsx("p", { children: content.offer.label }) : /* @__PURE__ */ jsx("p", { children: /* @__PURE__ */ jsx("a", { href: content.offer.href, rel: "noopener noreferrer", children: content.offer.label }) }))
+        ] }),
+        /* @__PURE__ */ jsx("section", { className: "sk-funnel-conversion", "aria-label": "Response form", children: preview ? /* @__PURE__ */ jsx("p", { className: "sk-funnel-preview", role: "status", children: "Form preview. Submissions are disabled." }) : conversion })
+      ] })
+    ] })
+  ] });
+}
+async function getPublishedFunnelPage(slug2, options) {
+  let path2;
+  try {
+    path2 = managedFunnelPath(slug2);
+  } catch (error) {
+    if (error instanceof FunnelValidationError) return null;
+    throw error;
+  }
+  const site2 = normalizeSiteHost(options.site);
+  if (!site2 || !/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/.test(site2)) throw new Error("An explicit canonical registered site is required");
+  const data = await serverApiFetch(`/api/public/funnels/${encodeURIComponent(slug2)}?site=${encodeURIComponent(site2)}`, {
+    apiKey: options.apiKey,
+    apiUrl: options.apiUrl,
+    revalidate: 0,
+    init: { cache: "no-store" },
+    logPrefix: "@sonordev/site-kit/landing"
+  });
+  if (data === null) return null;
+  const page = parsePublishedFunnelPage(data);
+  if (page.site !== site2 || page.path !== path2) throw new Error("Published funnel page scope mismatch");
+  return page;
+}
+function managedFunnelMetadata(page) {
+  const safe = parsePublishedFunnelPage(page);
+  return landingPageMetadata({ title: safe.content.headline, alternates: { canonical: `https://${safe.site}${safe.path}` } });
+}
+async function ManagedFunnelPage({ page: input, preview = false, configOptions }) {
+  const page = parsePublishedFunnelPage(input);
+  if (preview) return /* @__PURE__ */ jsx(FunnelPageContent, { page, preview: true });
+  const form = await ServerForm({ formId: page.conversion.formSlug, defer: false, enter: "none", configOptions });
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(LandingPage, { campaign: page.tracking.campaignSlug, robotsMeta: false }),
+    /* @__PURE__ */ jsx(FunnelPageContent, { page, conversion: form })
+  ] });
+}
+
+export { FunnelPageContent, ManagedFunnelPage, getPublishedFunnelPage, managedFunnelMetadata };

package/dist/{chunk-GLLFIE2R.js → chunk-G5FD7UXK.js}

@@ -1,12 +1,12 @@
 'use client';
 import { shellValuesToCarry } from './chunk-C2FZBUSS.js';
 import { useDeferredActivation } from './chunk-YC7ELZS3.js';
-import { normalizeFormConfig } from './chunk-5SQK3D53.js';
+import { normalizeFormConfig } from './chunk-TYSIAWC3.js';
 import { DEFAULT_HONEYPOT_FIELD } from './chunk-NJCTQH2P.js';
 import React, { useRef, useEffect, useState, useMemo, useCallback } from 'react';
 import { jsx, jsxs } from 'react/jsx-runtime';
 
-var loadInteractiveForm = () => import('./ManagedForm-4AACRHEY.js').then((m) => m.ManagedForm);
+var loadInteractiveForm = () => import('./ManagedForm-GJRGBM6W.js').then((m) => m.ManagedForm);
 var REPLAY_WAIT_MS = 8e3;
 function FormEnhancer({
   formId,

package/dist/{chunk-OFQ3BU52.js → chunk-HM7CDWFK.js}

@@ -1,4 +1,4 @@
-import { generateLLMsTxt, generateLLMsFullTxt, appendAgentAccessSection } from './chunk-URZTBPZO.js';
+import { generateLLMsTxt, generateLLMsFullTxt, appendAgentAccessSection } from './chunk-XZFOQ2V4.js';
 import { createHash } from 'crypto';
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';

package/dist/{chunk-Q4Y3WIHE.js → chunk-HWQPCZOX.js}

@@ -1,5 +1,5 @@
 'use client';
-import { sonorFetch } from './chunk-GDQKDL3E.js';
+import { sonorFetch } from './chunk-UYOE3HA4.js';
 import { useState, useCallback, useEffect } from 'react';
 import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
 

package/dist/{chunk-6KU7STM3.js → chunk-HY7ZEU2C.js}

@@ -12,7 +12,9 @@ var SITE_CACHE_TAGS = {
   /** Portfolio items (agency-site-kit). */
   portfolio: "portfolio",
   /** Products, services, events and membership plans (commerce-kit). */
-  commerce: "commerce"
+  commerce: "commerce",
+  /** Published managed landing pages. Draft previews never enter this cache. */
+  funnels: "sonor-funnels"
 };
 function isSiteRevalidatePong(body) {
   return typeof body === "object" && body !== null && body.ok === true && body.ping === true;

package/dist/chunk-IBHBEUZV.js

@@ -0,0 +1,27 @@
+// packages/press-kit/src/articles/html-tags.ts
+var blank = "\\t\\n\\f\\r ";
+var tagName = `[a-z][^${blank}/>]*(?![^${blank}/>])`;
+var attributeName = `[^${blank}/>][^${blank}/>=]*(?![^${blank}/>=])`;
+var attributeValue = `"[^"]*"|'[^']*'|[^${blank}>"'][^${blank}>]*(?![^${blank}>])|(?=>)`;
+var attribute = `${attributeName}(?:[${blank}]*=[${blank}]*(?:${attributeValue})|(?![${blank}]*=))`;
+var tagBody = `(?:[${blank}/]|${attribute})*>`;
+var comments = "<!--(?:-?>|[^]*?(?:--!?>|$))|<[!?][^>]*(?:>|$)|<\\/(?:>|[^a-z][^>]*(?:>|$))";
+var tokens = new RegExp(`${comments}|<\\/?${tagName}${tagBody}|<\\/?[a-z][^]*`, "gi");
+var completeTag = new RegExp(`^<\\/?(${tagName})${tagBody}$`, "i");
+function htmlTags() {
+  return new RegExp(tokens);
+}
+function htmlTagName(token) {
+  return completeTag.exec(token)?.[1].toLowerCase() ?? "";
+}
+function isClosingTag(tag) {
+  return tag.startsWith("</");
+}
+function openTagAttributes(tag) {
+  return tag.slice(1 + htmlTagName(tag).length, -1);
+}
+function stripHtmlTags(html) {
+  return html.replace(htmlTags(), "");
+}
+
+export { htmlTagName, htmlTags, isClosingTag, openTagAttributes, stripHtmlTags };

package/dist/{chunk-7HRYSLY2.js → chunk-IXZBOOAD.js}

@@ -1,8 +1,8 @@
-import { toHexColor, normalizeDesignTokens, designTokensHash } from './chunk-IHG36STL.js';
+import { toHexColor, normalizeDesignTokens, designTokensHash } from './chunk-XHYE24HU.js';
 import { contrastRatio, parseColor, relativeLuminance } from './chunk-S22FSH7C.js';
-import { resolveAnalyticsTarget } from './chunk-DLM4FFNH.js';
-import { sonorFetch } from './chunk-GDQKDL3E.js';
-import { SITE_KIT_VERSION } from './chunk-CFSIGEUW.js';
+import { resolveAnalyticsTarget } from './chunk-QTBAKOCZ.js';
+import { sonorFetch } from './chunk-UYOE3HA4.js';
+import { SITE_KIT_VERSION } from './chunk-MNORERMF.js';
 
 // src/website/design.ts
 var SITE_DESIGN_PATH = "/api/public/site/design";

package/dist/chunk-JESLPEST.js

@@ -0,0 +1,14 @@
+// src/landing/metadata.ts
+function landingPageMetadata(meta = {}) {
+  const callerRobots = meta.robots && typeof meta.robots === "object" ? meta.robots : void 0;
+  return {
+    ...meta,
+    robots: {
+      index: false,
+      follow: false,
+      ...callerRobots
+    }
+  };
+}
+
+export { landingPageMetadata };

package/dist/{chunk-BC7JMY4Z.js → chunk-JG53YJLM.js}

@@ -1,3 +1,4 @@
+import { htmlTags, htmlTagName, isClosingTag, openTagAttributes, stripHtmlTags } from './chunk-IBHBEUZV.js';
 import { createPublicationRoutes } from './chunk-4K735O3J.js';
 import { resolveTrailingSlash, applyTrailingSlash } from './chunk-YVKRYQRG.js';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
@@ -344,4 +345,60 @@ function readingTimeMinutes(post) {
   return typeof value === "number" && value > 0 ? value : null;
 }
 
-export { ClusterNavigation, ServiceCallout, ServiceCallouts, getAuthorSocialLinks, readingTimeMinutes };
+// packages/press-kit/src/articles/article-headings.ts
+function openTagAttribute(attributes, name) {
+  const wanted = name.toLowerCase();
+  const attribute = /([^\s"'<>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'<>=`]+)))?/g;
+  let match;
+  while (match = attribute.exec(attributes)) {
+    if (match[1].toLowerCase() === wanted) return match[2] ?? match[3] ?? match[4] ?? "";
+  }
+  return null;
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+}
+function scanHeadings(html) {
+  const tags = htmlTags();
+  const lineBreak = /[\n\r\u2028\u2029]/g;
+  const headings = [];
+  let waiting = [];
+  let nextBreak = -1;
+  let token;
+  while (token = tags.exec(html)) {
+    const level = /^h([2-4])$/.exec(htmlTagName(token[0]))?.[1];
+    if (!level) continue;
+    if (!isClosingTag(token[0])) {
+      waiting.push({ level: Number(level), attributes: openTagAttributes(token[0]), start: token.index, innerStart: tags.lastIndex });
+      continue;
+    }
+    for (const open of waiting) {
+      if (nextBreak < open.innerStart) {
+        lineBreak.lastIndex = open.innerStart;
+        nextBreak = lineBreak.exec(html)?.index ?? Infinity;
+      }
+      if (nextBreak < token.index) continue;
+      headings.push({
+        level: open.level,
+        attributes: open.attributes,
+        inner: html.slice(open.innerStart, token.index),
+        start: open.start,
+        end: tags.lastIndex
+      });
+      break;
+    }
+    waiting = [];
+  }
+  return headings;
+}
+function ownId(attributes) {
+  return openTagAttribute(attributes, "id");
+}
+function generateTableOfContents(html) {
+  return scanHeadings(html).map(({ level, attributes, inner }) => {
+    const text = stripHtmlTags(inner);
+    return { id: ownId(attributes) || slugify(text), text, level };
+  });
+}
+
+export { ClusterNavigation, ServiceCallout, ServiceCallouts, generateTableOfContents, getAuthorSocialLinks, ownId, readingTimeMinutes, scanHeadings, slugify };

package/dist/{chunk-FVXCQC7W.js → chunk-JWCCY72G.js}

@@ -1,5 +1,5 @@
 import { resolveSiteHost } from './chunk-FESKKJAS.js';
-import { configureSiteCredential, currentCredential } from './chunk-OEA7U4HJ.js';
+import { configureSiteCredential, currentCredential } from './chunk-P5PRR2BB.js';
 
 // src/shared/publishCredential.ts
 function publishSiteCredential({