@sonordev/site-kit 8.6.0 → 8.8.0

package/dist/portfolio/contract.js

@@ -1,2 +1,706 @@
-export { FRAME_READY_MESSAGE, METRIC_SOURCES, PORTFOLIO_CONTRACT_VERSION, PORTFOLIO_KPI_JSON_SCHEMA, carryReportedMetrics, curateHeroKpis, formatAttribution, isFrameReadyMessage, isHeadlineMetric, isLighthouseKpi, isMetricSource, metricSourceLabel, metricSourceProblem, shortAttribution } from '../chunk-EKBEOXTH.js';
+import { isBlockedPublicUrlHost } from '../chunk-XS2ORMUG.js';
+export { FRAME_READY_MESSAGE, isFrameReadyMessage } from '../chunk-64XODP7M.js';
 import '../chunk-PKBMQBKP.js';
+
+// src/contracts/portfolio.ts
+var PORTFOLIO_CONTRACT_VERSION = 1;
+var CASE_STUDY_STAGES = ["problem", "build", "proof", "outcome"];
+var CASE_STUDY_STAGE_COPY = {
+  problem: { name: "The problem", question: "What did the client come in with, and what was in the way?" },
+  build: { name: "The build", question: "What did we plan and make, and out of what?" },
+  proof: { name: "The proof", question: "How does the finished build hold up when measured?" },
+  outcome: { name: "The outcome", question: "What is the work doing for the client now?" }
+};
+var STAGE_NAME_MAX_CHARS = 24;
+function stageNamesProblems(names) {
+  if (names === void 0 || names === null) return [];
+  if (typeof names !== "object" || Array.isArray(names)) return ["stageNames must be an object"];
+  const problems = [];
+  for (const [stage, name] of Object.entries(names)) {
+    if (!CASE_STUDY_STAGES.includes(stage)) problems.push(`stageNames.${stage} is not a stage`);
+    else if (name === void 0 || name === null) continue;
+    else if (typeof name !== "string") problems.push(`stageNames.${stage} must be text`);
+    else if (name.trim().length > STAGE_NAME_MAX_CHARS)
+      problems.push(`stageNames.${stage} is over ${STAGE_NAME_MAX_CHARS} characters`);
+  }
+  return problems;
+}
+function stageName(names, stage) {
+  const own = names?.[stage]?.trim();
+  return own || CASE_STUDY_STAGE_COPY[stage].name;
+}
+var PORTFOLIO_SECTION_TYPES = [
+  "portfolioHero",
+  // problem
+  "portfolioChallenges",
+  "portfolioBeforeAfter",
+  // build
+  "portfolioStrategy",
+  "portfolioSiteArchitecture",
+  "portfolioDesignSystem",
+  "portfolioFeatureSpotlight",
+  "portfolioGallery",
+  "portfolioVideo",
+  "portfolioTechStack",
+  // proof
+  "portfolioPerformance",
+  "portfolioSpeedComparison",
+  "portfolioVerification",
+  // outcome
+  "portfolioResults",
+  "portfolioMetricsTimeline",
+  "portfolioConversionFunnel",
+  "portfolioServices",
+  "portfolioTeam",
+  "portfolioTestimonial",
+  "portfolioDetails",
+  // outside the story
+  "portfolioSeo",
+  "portfolioCTA"
+];
+function isPortfolioSectionType(value) {
+  return typeof value === "string" && PORTFOLIO_SECTION_TYPES.includes(value);
+}
+var SECTION_STAGE = {
+  portfolioHero: null,
+  portfolioChallenges: "problem",
+  portfolioBeforeAfter: "problem",
+  portfolioStrategy: "build",
+  portfolioSiteArchitecture: "build",
+  portfolioDesignSystem: "build",
+  portfolioFeatureSpotlight: "build",
+  portfolioGallery: "build",
+  portfolioVideo: "build",
+  portfolioTechStack: "build",
+  portfolioPerformance: "proof",
+  portfolioSpeedComparison: "proof",
+  portfolioVerification: "proof",
+  portfolioResults: "outcome",
+  portfolioMetricsTimeline: "outcome",
+  portfolioConversionFunnel: "outcome",
+  portfolioServices: "outcome",
+  portfolioTeam: "outcome",
+  portfolioTestimonial: "outcome",
+  portfolioDetails: "outcome",
+  portfolioSeo: null,
+  portfolioCTA: null
+};
+function sectionStage(type) {
+  return isPortfolioSectionType(type) ? SECTION_STAGE[type] : null;
+}
+var STAGE_CORE_SECTION = {
+  problem: "portfolioChallenges",
+  build: "portfolioStrategy",
+  proof: "portfolioPerformance",
+  outcome: "portfolioResults"
+};
+var STAGE_CORE_ALTERNATES = {
+  proof: ["portfolioVerification"]
+};
+var STAND_IN_HAS_CONTENT = {
+  portfolioVerification: (data) => readVerificationChecks(data).length > 0
+};
+var STAND_IN_EMPTY_COPY = {
+  portfolioVerification: "The verification is there, but none of its checks can be shown yet. Add a check, and say what it doesn't cover."
+};
+function stageCoreSections(stage) {
+  return [STAGE_CORE_SECTION[stage], ...STAGE_CORE_ALTERNATES[stage] ?? []];
+}
+var PORTFOLIO_SECTION_ORDER = Object.fromEntries(
+  PORTFOLIO_SECTION_TYPES.map((type, i) => [type, i])
+);
+var UNKNOWN_SECTION_ORDER = PORTFOLIO_SECTION_TYPES.length;
+function sectionOrder(type) {
+  return isPortfolioSectionType(type) ? PORTFOLIO_SECTION_ORDER[type] : UNKNOWN_SECTION_ORDER;
+}
+function stageOrder(type) {
+  if (type === "portfolioHero") return -1;
+  const stage = sectionStage(type);
+  return stage ? CASE_STUDY_STAGES.indexOf(stage) : CASE_STUDY_STAGES.length;
+}
+function orderSections(sections, options = {}) {
+  const list = [...sections ?? []];
+  const byStage = list.map((section, index) => ({ section, index }));
+  byStage.sort((a, b) => {
+    const stage = stageOrder(a.section.sectionType) - stageOrder(b.section.sectionType);
+    if (stage !== 0) return stage;
+    if (options.sectionsOrdered) return a.index - b.index;
+    const order = sectionOrder(a.section.sectionType) - sectionOrder(b.section.sectionType);
+    return order !== 0 ? order : a.index - b.index;
+  });
+  return byStage.map((s) => s.section);
+}
+function groupSectionsByStage(sections, options = {}) {
+  const ordered = orderSections(sections, options);
+  const groups = [];
+  for (const stage of CASE_STUDY_STAGES) {
+    const own = ordered.filter((s) => sectionStage(s.sectionType) === stage);
+    if (own.length) groups.push({ stage, index: groups.length + 1, sections: own });
+  }
+  return groups;
+}
+var STAGE_MISSING_COPY = {
+  problem: {
+    empty: "Nothing says what the client came in with. Add the challenges.",
+    noCore: "The problem is pictured but not stated. Add the challenges."
+  },
+  build: {
+    empty: "Nothing says what was planned or built. Add the strategy.",
+    noCore: "The build is shown but the plan behind it is missing. Add the strategy."
+  },
+  proof: {
+    empty: "Nothing measures the finished build. Add a performance measurement, or a verification when the screens are behind a sign-in.",
+    noCore: "The old site is compared but the finished build has no measurement of its own. Add a performance measurement."
+  },
+  outcome: {
+    empty: "Nothing says what the work is doing for the client. Add the results.",
+    noCore: "The outcome has supporting sections but no results. Add the results."
+  }
+};
+function caseStudyStageStatus(sections) {
+  const ordered = orderSections(sections);
+  return CASE_STUDY_STAGES.map((stage) => {
+    const own = ordered.filter(
+      (s) => isPortfolioSectionType(s.sectionType) && SECTION_STAGE[s.sectionType] === stage
+    );
+    const present = own.map((s) => s.sectionType);
+    const standIns = STAGE_CORE_ALTERNATES[stage] ?? [];
+    const emptyStandIns = own.filter(
+      (s) => standIns.includes(s.sectionType) && STAND_IN_HAS_CONTENT[s.sectionType]?.(s.data) === false
+    );
+    const complete = own.some(
+      (s) => s.sectionType === STAGE_CORE_SECTION[stage] || standIns.includes(s.sectionType) && !emptyStandIns.includes(s)
+    );
+    const copy = STAGE_MISSING_COPY[stage];
+    const missing = complete ? null : (emptyStandIns.length ? STAND_IN_EMPTY_COPY[emptyStandIns[0].sectionType] : void 0) ?? (present.length ? copy.noCore : copy.empty);
+    return { stage, present, complete, missing };
+  });
+}
+var NARRATIVE_MAX_CHARS = 320;
+function narrativeProblems(narrative) {
+  if (narrative === void 0 || narrative === null) return [];
+  if (typeof narrative !== "object") return ["narrative must be an object"];
+  const problems = [];
+  const n = narrative;
+  if (typeof n.thesis !== "string" || !n.thesis.trim()) problems.push("narrative.thesis is required");
+  else if (n.thesis.length > NARRATIVE_MAX_CHARS) problems.push(`narrative.thesis is over ${NARRATIVE_MAX_CHARS} characters`);
+  if (n.stages === void 0 || n.stages === null) return problems;
+  if (typeof n.stages !== "object") return [...problems, "narrative.stages must be an object"];
+  for (const [stage, lede] of Object.entries(n.stages)) {
+    if (!CASE_STUDY_STAGES.includes(stage)) {
+      problems.push(`narrative.stages.${stage} is not a stage (${CASE_STUDY_STAGES.join(", ")})`);
+      continue;
+    }
+    if (lede === void 0 || lede === null) continue;
+    if (typeof lede !== "string") problems.push(`narrative.stages.${stage} must be text`);
+    else if (lede.length > NARRATIVE_MAX_CHARS) problems.push(`narrative.stages.${stage} is over ${NARRATIVE_MAX_CHARS} characters`);
+  }
+  return problems;
+}
+var CASE_STUDY_NARRATIVE_JSON_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://sonor.io/schemas/case-study-narrative.v1.json",
+  title: "CaseStudyNarrative",
+  description: "The thesis of a case study and the lede that opens each of its four stages.",
+  type: "object",
+  required: ["thesis"],
+  properties: {
+    thesis: { type: "string", minLength: 1, maxLength: NARRATIVE_MAX_CHARS },
+    stages: {
+      type: "object",
+      properties: Object.fromEntries(
+        CASE_STUDY_STAGES.map((stage) => [stage, { type: "string", maxLength: NARRATIVE_MAX_CHARS }])
+      ),
+      additionalProperties: false
+    }
+  },
+  additionalProperties: false
+};
+function challengeId(position) {
+  return `c${position}`;
+}
+function caseStudyFlowProblems(input) {
+  const challenges = input.challenges ?? [];
+  const ids = challenges.map((c) => typeof c.id === "string" && c.id.trim() ? c.id.trim() : null);
+  if (!ids.some(Boolean)) return [];
+  const problems = [];
+  const known = new Set(ids.filter((id) => !!id));
+  if (known.size !== ids.filter(Boolean).length) problems.push("two challenges share an id");
+  ids.forEach((id, i) => {
+    if (!id) problems.push(`challenge ${i + 1} has no id while the others do`);
+  });
+  const resolved = /* @__PURE__ */ new Set();
+  const proven = /* @__PURE__ */ new Set();
+  for (const phase of input.phases ?? []) {
+    for (const ref of phase.resolves ?? []) {
+      if (!known.has(ref)) problems.push(`a strategy phase resolves "${ref}", which is not a challenge`);
+      else resolved.add(ref);
+    }
+  }
+  for (const result of input.results ?? []) {
+    for (const ref of result.proves ?? []) {
+      if (!known.has(ref)) problems.push(`a result proves "${ref}", which is not a challenge`);
+      else proven.add(ref);
+    }
+  }
+  const nameOf = (id) => {
+    const c = challenges.find((x) => x.id === id);
+    return c?.title?.trim() ? `"${c.title.trim()}"` : id;
+  };
+  for (const id of known) {
+    if (!resolved.has(id)) problems.push(`no strategy phase resolves challenge ${nameOf(id)}`);
+    if (!proven.has(id)) problems.push(`no result proves challenge ${nameOf(id)}`);
+  }
+  return problems;
+}
+var ISO_DAY_RE = /^\d{4}-\d{2}-\d{2}$/;
+function isRealDay(value) {
+  if (typeof value !== "string" || !ISO_DAY_RE.test(value)) return false;
+  const [year, month, day] = value.split("-").map(Number);
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+var VERIFICATION_MAX_CHECKS = 8;
+var VERIFICATION_CHECK_FIELDS = ["label", "result", "measured", "where", "method", "date", "scope"];
+var VERIFICATION_FIELD_MAX_CHARS = {
+  label: 80,
+  result: 120,
+  measured: 200,
+  where: 200,
+  method: 240,
+  scope: 240
+};
+var VERIFICATION_EARLIEST_DAY = "2000-01-01";
+function latestVerificationDay(now = /* @__PURE__ */ new Date()) {
+  const tomorrow = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1));
+  return tomorrow.toISOString().slice(0, 10);
+}
+function wordsOf(text) {
+  return text.toLowerCase().replace(/['’]/g, "").split(/[^a-z0-9]+/).filter(Boolean);
+}
+var FILLER_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "of",
+  "to",
+  "at",
+  "as",
+  "in",
+  "is",
+  "are",
+  "be",
+  "it",
+  "this",
+  "that",
+  "any",
+  "all"
+]);
+var PLACEHOLDER_WORDS = /* @__PURE__ */ new Set([
+  ...FILLER_WORDS,
+  "n",
+  "na",
+  "nil",
+  "null",
+  "undefined",
+  "none",
+  "nothing",
+  "else",
+  "no",
+  "not",
+  "yes",
+  "ok",
+  "okay",
+  "x",
+  "xx",
+  "xxx",
+  "tbd",
+  "tbc",
+  "tba",
+  "todo",
+  "lorem",
+  "ipsum",
+  "misc",
+  "etc",
+  "various",
+  "multiple",
+  "same",
+  "above",
+  "see",
+  "here",
+  "there",
+  "applicable",
+  "available",
+  "relevant",
+  "required",
+  "needed",
+  "specified",
+  "unspecified",
+  "provided",
+  "given",
+  "stated",
+  "known",
+  "unknown",
+  "apply",
+  "applies",
+  "exist",
+  "exists",
+  "restriction",
+  "restrictions",
+  "limit",
+  "limits",
+  "limitation",
+  "limitations",
+  "caveat",
+  "caveats",
+  "exclusion",
+  "exclusions",
+  "exception",
+  "exceptions",
+  "constraint",
+  "constraints",
+  "gap",
+  "gaps",
+  "issue",
+  "issues",
+  "problem",
+  "problems",
+  "boundary",
+  "boundaries"
+]);
+var LIMIT_WORDS = /* @__PURE__ */ new Set([
+  "only",
+  "not",
+  "never",
+  "cannot",
+  "except",
+  "beyond",
+  "outside",
+  "just",
+  "solely",
+  "merely",
+  "unless",
+  "besides",
+  "untested",
+  "unmeasured",
+  "unchecked",
+  "unverified",
+  // negative contractions, apostrophe dropped
+  "isnt",
+  "arent",
+  "wasnt",
+  "werent",
+  "dont",
+  "doesnt",
+  "didnt",
+  "cant",
+  "couldnt",
+  "wont",
+  "wouldnt",
+  "hasnt",
+  "havent",
+  "hadnt",
+  "shouldnt",
+  "mustnt",
+  "neednt"
+]);
+var EXCLUSION_WORDS = /* @__PURE__ */ new Set([
+  "exclude",
+  "excludes",
+  "excluded",
+  "excluding",
+  "omit",
+  "omits",
+  "omitted",
+  "skip",
+  "skips",
+  "skipped",
+  "limited"
+]);
+var NEGATOR_WORDS = /* @__PURE__ */ new Set(["no", "none", "nothing", "without"]);
+function isPlaceholderText(text) {
+  const words = wordsOf(text);
+  return words.length === 0 || words.every((word) => PLACEHOLDER_WORDS.has(word));
+}
+function isVacuousScope(scope) {
+  const words = wordsOf(scope);
+  if (words.length < 2) return true;
+  const wordAfter = (i) => {
+    for (let j = i + 1; j < words.length; j++) if (!FILLER_WORDS.has(words[j])) return words[j];
+    return void 0;
+  };
+  const wordBefore = (i) => {
+    for (let j = i - 1; j >= 0; j--) if (!FILLER_WORDS.has(words[j])) return words[j];
+    return void 0;
+  };
+  const marksLimit = words.map((word, i) => {
+    if (NEGATOR_WORDS.has(word)) {
+      const next = wordAfter(i);
+      return next !== void 0 && !PLACEHOLDER_WORDS.has(next) && !EXCLUSION_WORDS.has(next);
+    }
+    if (EXCLUSION_WORDS.has(word)) return !NEGATOR_WORDS.has(wordBefore(i) ?? "");
+    return LIMIT_WORDS.has(word);
+  });
+  if (!marksLimit.some(Boolean)) return true;
+  return !words.some(
+    (word) => !PLACEHOLDER_WORDS.has(word) && !LIMIT_WORDS.has(word) && !EXCLUSION_WORDS.has(word) && !NEGATOR_WORDS.has(word)
+  );
+}
+function carriesCredentials(text) {
+  for (let at = text.indexOf("://"); at !== -1; at = text.indexOf("://", at + 3)) {
+    for (let i = at + 3; i < text.length; i++) {
+      const char = text[i];
+      if (char === "@") return true;
+      if (char === "/" || char === "?" || char === "#" || /\s/.test(char)) break;
+    }
+  }
+  return false;
+}
+var WEB_ADDRESS = /^https?:\/\//i;
+var BARE_PRIVATE_ADDRESS = /^(?:localhost|\d{1,3}(?:\.\d{1,3}){3}|\[[0-9a-f:.]+\])(?::\d+)?(?:[/?#]|$)/i;
+function trimPunctuation(word) {
+  let start = 0;
+  let end = word.length;
+  while (start < end && `("'<`.includes(word[start])) start++;
+  while (end > start && `)"'>.,;!?`.includes(word[end - 1])) end--;
+  return word.slice(start, end);
+}
+function namesPrivateAddress(text) {
+  return text.split(/\s+/).some((word) => {
+    const token = trimPunctuation(word);
+    const address = WEB_ADDRESS.test(token) ? token : BARE_PRIVATE_ADDRESS.test(token) ? `http://${token}` : null;
+    if (!address) return false;
+    try {
+      return isBlockedPublicUrlHost(new URL(address).hostname);
+    } catch {
+      return false;
+    }
+  });
+}
+function looksLikePathOrHost(token) {
+  const pieces = token.split(/[/\\.]/).filter(Boolean);
+  return pieces.length >= 2 && pieces.every((piece) => /^[\w:-]{2,}$/.test(piece));
+}
+function whereProblem(where) {
+  if (carriesCredentials(where)) return "must not carry a username or password";
+  if (namesPrivateAddress(where)) return "must be a public address, not localhost or a private network";
+  const named = !isPlaceholderText(where) && (verificationLink(where) !== null || where.split(/\s+/).length >= 2 || looksLikePathOrHost(where));
+  return named ? null : "must say where the check ran: a public web address, or a screen or file named in words";
+}
+var NOT_PLAIN_LINE = /[\p{Cc}\u2028\u2029\u200B-\u200F\u202A-\u202E\u2066-\u2069\uFEFF]/u;
+function checkProblems(check, at, latestDay, strict) {
+  if (!check || typeof check !== "object" || Array.isArray(check)) return [`${at} must be an object`];
+  const entry = check;
+  const problems = [];
+  if (strict) {
+    for (const key of Object.keys(entry)) {
+      if (!VERIFICATION_CHECK_FIELDS.includes(key)) problems.push(`${at}.${key} is not a field`);
+    }
+  }
+  for (const field of VERIFICATION_CHECK_FIELDS) {
+    const value = entry[field];
+    if (typeof value !== "string" || !value.trim()) {
+      problems.push(
+        field === "scope" ? `${at}.scope is required: say what the check does not cover` : `${at}.${field} is required`
+      );
+      continue;
+    }
+    if (NOT_PLAIN_LINE.test(value)) problems.push(`${at}.${field} must be one line of plain text`);
+    if (field === "date") continue;
+    const max = VERIFICATION_FIELD_MAX_CHARS[field];
+    if (value.trim().length > max) problems.push(`${at}.${field} is over ${max} characters`);
+  }
+  const date = typeof entry.date === "string" ? entry.date.trim() : "";
+  if (date) {
+    if (!isRealDay(date)) problems.push(`${at}.date must be a real day, YYYY-MM-DD`);
+    else if (date < VERIFICATION_EARLIEST_DAY) problems.push(`${at}.date must be ${VERIFICATION_EARLIEST_DAY} or later`);
+    else if (date > latestDay) problems.push(`${at}.date is in the future`);
+  }
+  const text = (field) => {
+    const value = entry[field];
+    return typeof value === "string" && value.trim() && value.trim().length <= VERIFICATION_FIELD_MAX_CHARS[field] ? value.trim() : null;
+  };
+  const where = text("where");
+  const problem = where === null ? null : whereProblem(where);
+  if (problem) problems.push(`${at}.where ${problem}`);
+  const scope = text("scope");
+  if (scope !== null && isVacuousScope(scope)) {
+    problems.push(`${at}.scope must state a limit: what the check does not cover, using a word like "only", "not", "except" or "without"`);
+  }
+  return problems;
+}
+function verificationProblems(data, options = {}) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) return ["verification data must be an object"];
+  const { checks, ...rest } = data;
+  const problems = Object.keys(rest).map((key) => `${key} is not a field of a verification`);
+  if (!Array.isArray(checks) || checks.length === 0) return [...problems, "checks must list at least one check"];
+  if (checks.length > VERIFICATION_MAX_CHECKS) {
+    problems.push(`checks is over ${VERIFICATION_MAX_CHECKS} entries; keep the ones that matter`);
+  }
+  const latestDay = options.latestDay ?? latestVerificationDay();
+  checks.forEach((check, i) => problems.push(...checkProblems(check, `checks[${i}]`, latestDay, true)));
+  return problems;
+}
+function readVerificationChecks(data, options = {}) {
+  const checks = data?.checks;
+  if (!Array.isArray(checks)) return [];
+  const latestDay = options.latestDay ?? latestVerificationDay();
+  const shown = [];
+  checks.forEach((check, i) => {
+    if (shown.length >= VERIFICATION_MAX_CHECKS || checkProblems(check, `checks[${i}]`, latestDay, false).length) return;
+    const entry = check;
+    shown.push(
+      Object.fromEntries(VERIFICATION_CHECK_FIELDS.map((field) => [field, entry[field].trim()]))
+    );
+  });
+  return shown;
+}
+function verificationLink(where) {
+  const text = where.trim();
+  if (!text || /\s/.test(text)) return null;
+  try {
+    const url = new URL(text);
+    if (url.protocol !== "https:" && url.protocol !== "http:") return null;
+    if (url.username || url.password || isBlockedPublicUrlHost(url.hostname)) return null;
+    return url.toString();
+  } catch {
+    return null;
+  }
+}
+var PORTFOLIO_VERIFICATION_JSON_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://sonor.io/schemas/portfolio-verification.v1.json",
+  title: "PortfolioVerificationData",
+  description: "A short list of checks on the finished build. Each says what was checked, where, how, when, what came out, and what it does not cover.",
+  type: "object",
+  required: ["checks"],
+  properties: {
+    checks: {
+      type: "array",
+      minItems: 1,
+      maxItems: VERIFICATION_MAX_CHECKS,
+      items: {
+        type: "object",
+        required: [...VERIFICATION_CHECK_FIELDS],
+        properties: {
+          label: { type: "string", minLength: 1, maxLength: VERIFICATION_FIELD_MAX_CHARS.label },
+          result: { type: "string", minLength: 1, maxLength: VERIFICATION_FIELD_MAX_CHARS.result },
+          measured: { type: "string", minLength: 1, maxLength: VERIFICATION_FIELD_MAX_CHARS.measured },
+          where: { type: "string", minLength: 1, maxLength: VERIFICATION_FIELD_MAX_CHARS.where },
+          method: { type: "string", minLength: 1, maxLength: VERIFICATION_FIELD_MAX_CHARS.method },
+          date: { type: "string", pattern: "^\\d{4}-\\d{2}-\\d{2}$" },
+          scope: { type: "string", minLength: 1, maxLength: VERIFICATION_FIELD_MAX_CHARS.scope }
+        },
+        additionalProperties: false
+      }
+    }
+  },
+  additionalProperties: false
+};
+var LIGHTHOUSE_RE = /lighthouse/i;
+function isLighthouseKpi(kpi) {
+  return LIGHTHOUSE_RE.test(kpi.label || "");
+}
+function curateHeroKpis(kpis) {
+  const business = kpis.filter((k) => !isLighthouseKpi(k));
+  const lighthouse = kpis.filter(isLighthouseKpi);
+  if (lighthouse.length <= 1) return kpis;
+  const allPerfect = lighthouse.length >= 4 && lighthouse.every((k) => k.value === 100);
+  const summary = allPerfect ? {
+    ...lighthouse[0],
+    label: "Lighthouse, all 4 categories",
+    description: "Perfect scores across performance, SEO, accessibility, and best practices."
+  } : lighthouse.find((k) => /performance/i.test(k.label)) ?? lighthouse[0];
+  return [...business, summary];
+}
+var PORTFOLIO_KPI_JSON_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://sonor.io/schemas/portfolio-kpi.v1.json",
+  title: "KpiLike",
+  description: "The subset of a portfolio KPI tile the Lighthouse-collapse policy reads.",
+  type: "object",
+  required: ["label", "value"],
+  properties: {
+    label: { type: "string" },
+    value: { type: "number" },
+    description: { type: "string" },
+    source: { enum: ["measured", "reported", "estimated"] },
+    reportedBy: {
+      type: "object",
+      required: ["name", "organization", "date"],
+      properties: {
+        name: { type: "string", minLength: 1 },
+        role: { type: "string" },
+        organization: { type: "string", minLength: 1 },
+        date: { type: "string", pattern: "^\\d{4}-\\d{2}-\\d{2}$" }
+      }
+    }
+  },
+  // A reported number is only valid with someone named behind it.
+  if: { properties: { source: { const: "reported" } }, required: ["source"] },
+  then: { required: ["reportedBy"] },
+  additionalProperties: true
+};
+var METRIC_SOURCES = ["measured", "reported", "estimated"];
+var MONTHS = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+function isMetricSource(value) {
+  return typeof value === "string" && METRIC_SOURCES.includes(value);
+}
+function metricSourceProblem(metric) {
+  if (metric.source === void 0 || metric.source === null) return null;
+  if (!isMetricSource(metric.source)) return `source must be one of ${METRIC_SOURCES.join(", ")}`;
+  if (metric.source !== "reported") return null;
+  const by = metric.reportedBy;
+  if (!by || typeof by !== "object") {
+    return "a reported number needs reportedBy: who reported it, where they work, and when";
+  }
+  if (typeof by.name !== "string" || !by.name.trim()) return "reportedBy.name is required";
+  if (typeof by.organization !== "string" || !by.organization.trim()) {
+    return "reportedBy.organization is required";
+  }
+  if (typeof by.date !== "string" || !isRealDay(by.date)) {
+    return "reportedBy.date must be a real day, YYYY-MM-DD";
+  }
+  if (by.role !== void 0 && typeof by.role !== "string") return "reportedBy.role must be text";
+  return null;
+}
+function isHeadlineMetric(metric) {
+  if (metric.source === "measured") return true;
+  return metric.source === "reported" && metricSourceProblem(metric) === null;
+}
+function metricSourceLabel(source) {
+  if (source === "measured") return "Measured";
+  if (source === "reported") return "Client-reported";
+  if (source === "estimated") return "Estimated";
+  return null;
+}
+function formatAttribution(by) {
+  const [year, month, day] = by.date.split("-").map(Number);
+  const when = MONTHS[month - 1] ? `${MONTHS[month - 1]} ${day}, ${year}` : by.date;
+  return [`Reported by ${by.name.trim()}`, by.role?.trim(), by.organization.trim(), when].filter(Boolean).join(", ");
+}
+function shortAttribution(by) {
+  return `per ${by.organization.trim()}`;
+}
+function carryReportedMetrics(previous, next, keyOf) {
+  const norm = (metric) => String(keyOf(metric) ?? "").trim().toLowerCase();
+  const reported = (previous ?? []).filter((m) => m?.source === "reported");
+  const taken = new Set(reported.map(norm));
+  const generated = (next ?? []).filter((m) => m && m.source !== "reported" && !taken.has(norm(m)));
+  return [...reported, ...generated];
+}
+
+export { CASE_STUDY_NARRATIVE_JSON_SCHEMA, CASE_STUDY_STAGES, CASE_STUDY_STAGE_COPY, METRIC_SOURCES, NARRATIVE_MAX_CHARS, PORTFOLIO_CONTRACT_VERSION, PORTFOLIO_KPI_JSON_SCHEMA, PORTFOLIO_SECTION_ORDER, PORTFOLIO_SECTION_TYPES, PORTFOLIO_VERIFICATION_JSON_SCHEMA, SECTION_STAGE, STAGE_CORE_ALTERNATES, STAGE_CORE_SECTION, STAGE_NAME_MAX_CHARS, VERIFICATION_CHECK_FIELDS, VERIFICATION_EARLIEST_DAY, VERIFICATION_FIELD_MAX_CHARS, VERIFICATION_MAX_CHECKS, carryReportedMetrics, caseStudyFlowProblems, caseStudyStageStatus, challengeId, curateHeroKpis, formatAttribution, groupSectionsByStage, isHeadlineMetric, isLighthouseKpi, isMetricSource, isPlaceholderText, isPortfolioSectionType, isRealDay, isVacuousScope, latestVerificationDay, metricSourceLabel, metricSourceProblem, narrativeProblems, orderSections, readVerificationChecks, sectionStage, shortAttribution, stageCoreSections, stageName, stageNamesProblems, verificationLink, verificationProblems };