@warpgogol/werkstatt-shared 0.2.0

package/src/share/semantic/build-page.ts

@@ -0,0 +1,309 @@
+/*
+<MODULE_CONTRACT>
+<purpose>RFC-0144: the single, framework-agnostic per-page semantic builder. Orchestration that was duplicated between the disk loader (@warpgogol/site-kernel-content) and the Astro path (formerly @warpgogol/business, deleted in RFC-0471) lives here once. Where the bytes come from is injected via a small SemanticContentReader seam; the disk path supplies an fs reader, the Astro path an astro:content reader. (A future RFC-0141 node ContentSourceProvider can back both readers — see RFC-0144 staging.)</purpose>
+<non-goals>
+  <item>Do not read files or import astro:content — all I/O flows through the injected reader.</item>
+  <item>Do not assemble the organization profile or iterate system.md pages — callers own that.</item>
+  <item>Do not resolve output projection (RFC-0143) — callers attach model.output.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0144: initial extraction of the shared per-page builder from the two duplicated paths.</item>
+  <item>RFC-0372: unified all page types through extractContentBlocks + extractPageHeading; removed home-specific branch and extractMarkdownProps; extractContentBlocks returns SemanticBlock[].</item>
+</CHANGE_SUMMARY>
+*/
+
+import type {
+  SemanticBlock,
+  SemanticBreadcrumb,
+  SemanticFaqEntry,
+  SemanticInitiative,
+  SemanticOrganization,
+  SemanticPageModel,
+  SemanticPageType,
+  SemanticPerson,
+} from "./models.ts";
+import { BLOCK_EXTRACTORS } from "./block-extraction.ts";
+import "./block-extractors/index.ts";
+import {
+  buildMarkdownPageSemantic,
+  type MarkdownPageInput,
+} from "./page-builders/markdown-page.ts";
+import { extractAnswerBlocksFromMarkdown, toSemanticAnswerBlocks } from "./page-utils.ts";
+import type { DerivedPriceEntry } from "./price-marker-resolver.ts";
+import {
+  resolvePriceMarkersForSemantic,
+  resolveAmountMarkersForSemantic,
+} from "./price-marker-resolver.ts";
+
+/** The organization profile + enrichment pools the builder draws from. */
+export interface SemanticBuildProfile {
+  organization: SemanticOrganization;
+  people: SemanticPerson[];
+  initiatives: SemanticInitiative[];
+}
+
+/**
+ * The injected content-read seam. Each implementation keeps its source's
+ * behavior (the fs reader substitutes content references per RFC-0045; the
+ * astro:content reader returns raw body). Returning `null` frontmatter means
+ * the page does not exist for the language and is skipped by the caller.
+ */
+export interface SemanticContentReader {
+  getPageFrontmatter(pageId: string, lang: string): Promise<Record<string, unknown> | null>;
+  getProseBody(proseSlug: string, lang: string): Promise<string>;
+  getHomeLabel(lang: string): Promise<string>;
+  getFaqEntries(lang: string): Promise<SemanticFaqEntry[]>;
+  /**
+   * RFC-0767: load derived prices for price marker resolution. Returns null
+   * when the derived prices file does not exist (ENOENT). Synchronous because
+   * the underlying loader uses readFileSync — the method is on the reader
+   * interface to keep build-page.ts I/O-free per its module contract.
+   */
+  getDerivedPrices(): Record<string, DerivedPriceEntry[]> | null;
+}
+
+export interface SemanticPageBuildArgs {
+  pageId: string;
+  semanticType: SemanticPageType;
+  lang: string;
+  url: URL | string;
+  profile: SemanticBuildProfile;
+  /**
+   * RFC-0377: optional audience override for the page. If omitted, consumers fall back to the
+   * SemanticPageType derivation map (AUDIENCE_BY_PAGE_TYPE).
+   */
+  audience?: string;
+  /**
+   * RFC-0195: synthetic frontmatter used when the reader has no content entry for `pageId`
+   * (e.g. a Programmatic Surface page baked into the route artifact rather than a pages/*.md file).
+   * Shaped like a page entry: `{ title, description, blocks }`.
+   */
+  fallbackFrontmatter?: Record<string, unknown>;
+  /**
+   * RFC-0229: the canonical breadcrumb trail (Home → live ancestors → self) resolved by the render
+   * pipeline. When supplied it becomes the page's `breadcrumbs` (driving both the JSON-LD
+   * BreadcrumbList and the visible section); when omitted the builder falls back to a flat trail.
+   */
+  breadcrumbs?: SemanticBreadcrumb[];
+}
+
+/** semanticType → which enrichment pool to attach. */
+const PAGE_ENRICHMENT_MAP: Partial<Record<SemanticPageType, "people" | "initiatives">> = {
+  about: "people",
+  projects: "initiatives",
+};
+
+/** semanticType values whose pages embed the FAQ list. */
+const PAGE_INCLUDE_FAQ: ReadonlySet<SemanticPageType> = new Set<SemanticPageType>([
+  "donationContact",
+]);
+
+/**
+ * Resolve the FAQ entries a page should embed (drives the FAQPage JSON-LD node).
+ * A page carries FAQ when its semanticType opts in (PAGE_INCLUDE_FAQ), it is the
+ * canonical `faq` page, or it declares a visible `faq-list` block. When `faq-list`
+ * blocks declare tags, entries are filtered to those tags (RFC-0208). Returns
+ * undefined when the page should carry no FAQPage. Shared by the home and
+ * markdown builder paths so a `faq-list` block on the home emits FAQPage too.
+ */
+async function resolveFaqEntries(
+  reader: SemanticContentReader,
+  lang: string,
+  blocks: Array<Record<string, unknown>>,
+  pageId: string,
+  semanticType: SemanticPageType,
+): Promise<SemanticFaqEntry[] | undefined> {
+  const faqBlocks = blocks.filter((b) => b["type"] === "faq-list");
+  if (!(PAGE_INCLUDE_FAQ.has(semanticType) || pageId === "faq" || faqBlocks.length > 0)) {
+    return undefined;
+  }
+  const faqEntries = await reader.getFaqEntries(lang);
+  if (faqEntries.length === 0) return undefined;
+  const tags = new Set(
+    faqBlocks
+      .map((b) => ((b["props"] ?? b) as Record<string, unknown>)["tag"] as string | undefined)
+      .filter((t): t is string => typeof t === "string" && t.length > 0),
+  );
+  if (tags.size > 0) {
+    const filtered = faqEntries.filter((e) => e.tags?.some((t) => tags.has(t)));
+    return filtered.length > 0 ? filtered : undefined;
+  }
+  return faqEntries;
+}
+
+/** RFC-0372: extract semantic text from declared blocks into SemanticBlock[]. */
+function extractContentBlocks(
+  blocks: Array<Record<string, unknown>>,
+  ctx: { pageId: string; lang: string; siteUrl: string },
+): SemanticBlock[] {
+  const result: SemanticBlock[] = [];
+  for (const block of blocks) {
+    const blockType = String(block["type"] ?? "");
+    const blockId = String(block["id"] ?? `block-${result.length}`);
+    if (!blockType) continue;
+    const extractor = BLOCK_EXTRACTORS.get(blockType);
+    if (!extractor) continue;
+    const props = (block["props"] ?? block) as Record<string, unknown>;
+    const extracted = extractor.extract(props, ctx);
+    // RFC-0372: always push the block — no-op extractors return heading: "".
+    result.push({
+      id: blockId,
+      blockType,
+      heading: extracted.heading ?? "",
+      summary: extracted.lead,
+      body: extracted.body,
+      items: extracted.items,
+      extractedAt: new Date().toISOString(),
+      extractorVersion: "1.0.0",
+    });
+  }
+  return result;
+}
+
+/**
+ * RFC-0372: Scan all frontmatter blocks in declaration order for header.heading / header.subheading.
+ * Works with any block type that has header props (hero-decision-card, markdown, etc.) — not
+ * limited to type: "markdown". Falls back to frontmatter title/description.
+ */
+function extractPageHeading(
+  blocks: Array<Record<string, unknown>>,
+  fallbackTitle: string,
+  fallbackDescription: string,
+): { heading: string; lead?: string } {
+  let heading = fallbackTitle;
+  let lead: string | undefined;
+  for (const block of blocks) {
+    const props = (block["props"] ?? block) as Record<string, unknown>;
+    const headerHeading =
+      props["header"] && typeof props["header"] === "object"
+        ? safeString((props["header"] as Record<string, unknown>)["heading"])
+        : safeString(props["heading"]);
+    const headerSubheading =
+      props["header"] && typeof props["header"] === "object"
+        ? safeString((props["header"] as Record<string, unknown>)["subheading"])
+        : safeString(props["lead"]);
+    if (!heading || heading === fallbackTitle) {
+      if (headerHeading) heading = headerHeading;
+    }
+    if (!lead) {
+      if (headerSubheading) lead = headerSubheading;
+    }
+    if (heading !== fallbackTitle && lead) break;
+  }
+  if (!lead) lead = fallbackDescription || undefined;
+  return { heading, ...(lead ? { lead } : {}) };
+}
+
+function safeString(v: unknown): string | undefined {
+  return typeof v === "string" && v.length > 0 ? v : undefined;
+}
+
+/**
+ * RFC-0144/RFC-0372: build a single SemanticPageModel via the injected reader. This is
+ * the one place the per-page construction logic lives. All page types (including home)
+ * go through the same unified pipeline: extractContentBlocks → extractPageHeading →
+ * buildMarkdownPageSemantic with a merged blocks array. `model.organization`
+ * and `model.output` (RFC-0143) are attached by the caller.
+ */
+export async function buildSemanticPageModelWith(
+  reader: SemanticContentReader,
+  args: SemanticPageBuildArgs,
+): Promise<SemanticPageModel | null> {
+  const { pageId, semanticType, lang, url, profile } = args;
+
+  const frontmatter = (await reader.getPageFrontmatter(pageId, lang)) ?? args.fallbackFrontmatter;
+  if (!frontmatter) return null;
+
+  const title = (frontmatter["title"] as string) ?? "";
+  const rawDescription = (frontmatter["description"] as string) ?? "";
+
+  const allBlocks = (frontmatter["blocks"] as Array<Record<string, unknown>> | undefined) ?? [];
+
+  // RFC-0372: Extract block-derived SemanticBlocks from frontmatter.
+  const blockDerived = extractContentBlocks(allBlocks, { pageId, lang, siteUrl: url.toString() });
+
+  // RFC-0372: Extract prose from contentRef (if any) and convert to SemanticBlock[].
+  // Scan frontmatter blocks for a contentRef in any block's props (typically markdown blocks).
+  let proseBlocks: SemanticBlock[] = [];
+  for (const block of allBlocks) {
+    const props = (block["props"] ?? block) as Record<string, unknown>;
+    const contentRef = props["contentRef"] as string | undefined;
+    if (contentRef) {
+      const proseSlug = contentRef.replace(/^prose\//, "");
+      const bodyText = await reader.getProseBody(proseSlug, lang);
+      const markdownBlocks = extractAnswerBlocksFromMarkdown(bodyText);
+      proseBlocks = toSemanticAnswerBlocks(markdownBlocks);
+      break;
+    }
+  }
+
+  // RFC-0372: Merge block-derived and prose-derived blocks in frontmatter declaration order.
+  // For pages with both frontmatter blocks and prose, prose blocks are appended after
+  // block-derived blocks (prose contentRef is typically the markdown body following the
+  // structured blocks).
+  const mergedBlocks = [...blockDerived, ...proseBlocks];
+
+  // RFC-0372: Extract page heading from frontmatter block props (any block type with
+  // header.heading), falling back to title/description.
+  const { heading, lead } = extractPageHeading(allBlocks, title, rawDescription);
+
+  // RFC-0767: resolve {price:offering:chargeRef} markers to source-currency (EUR)
+  // strings for JSON-LD and meta tags. Markers in heading, lead, and description
+  // are resolved before entering the SemanticPageModel.
+  const derivedPrices = reader.getDerivedPrices();
+  const resolvedHeading = resolveAmountMarkersForSemantic(
+    resolvePriceMarkersForSemantic(heading, lang, derivedPrices),
+    lang,
+  );
+  const resolvedLead = lead
+    ? resolveAmountMarkersForSemantic(
+        resolvePriceMarkersForSemantic(lead, lang, derivedPrices),
+        lang,
+      )
+    : undefined;
+  const resolvedDescription = resolveAmountMarkersForSemantic(
+    resolvePriceMarkersForSemantic(rawDescription, lang, derivedPrices),
+    lang,
+  );
+
+  const baseInput = { lang, url, title, description: resolvedDescription };
+
+  const homeLabel = await reader.getHomeLabel(lang);
+  const enrichmentKey = PAGE_ENRICHMENT_MAP[semanticType];
+
+  const input: MarkdownPageInput = {
+    type: semanticType,
+    ...baseInput,
+    ...(args.audience ? { audience: args.audience } : {}),
+    heading: resolvedHeading,
+    ...(resolvedLead ? { lead: resolvedLead } : {}),
+    blocks: mergedBlocks,
+    breadcrumbsContent: { homeLabel },
+    ...(args.breadcrumbs && args.breadcrumbs.length > 0 ? { breadcrumbs: args.breadcrumbs } : {}),
+    ...(enrichmentKey === "people" ? { people: profile.people } : {}),
+    ...(enrichmentKey === "initiatives" ? { initiatives: profile.initiatives } : {}),
+    // RFC-0200: a person profile page attaches just the profiled person (matched by
+    // name) so a Person JSON-LD node emits as the page's subject.
+    ...(semanticType === "person"
+      ? { people: profile.people.filter((p) => p.name === title) }
+      : {}),
+  };
+
+  const faqEntries = await resolveFaqEntries(reader, lang, allBlocks, pageId, semanticType);
+  if (faqEntries) {
+    input.faqEntries = faqEntries.map((e) => ({
+      ...e,
+      question: resolveAmountMarkersForSemantic(
+        resolvePriceMarkersForSemantic(e.question, lang, derivedPrices),
+        lang,
+      ),
+      answer: resolveAmountMarkersForSemantic(
+        resolvePriceMarkersForSemantic(e.answer, lang, derivedPrices),
+        lang,
+      ),
+    }));
+  }
+
+  return buildMarkdownPageSemantic(input);
+}

package/src/share/semantic/business-projection.ts

@@ -0,0 +1,278 @@
+/*
+<MODULE_CONTRACT>
+<purpose>RFC-0148: pure projectors that map canonical business-schema data into the semantic model, plus the projection visibility boundary. Framework-agnostic and side-effect-free, so the disk llms path and the Astro JSON-LD path project every business file identically. Lives in @warpgogol/werkstatt-shared/share (not @warpgogol/werkstatt-site/pbp) because @warpgogol/werkstatt-site/pbp depends on @warpgogol/site-kernel-content — placing the projectors here keeps the node disk loader cycle-free.</purpose>
+<non-goals>
+  <item>Do not read files — pure mapping over already-loaded data.</item>
+  <item>Do not project privacy-sensitive domains (external-services, compliance).</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0148: initial projection registry — offer + location projectors and the visibility boundary.</item>
+  <item>RFC-0287: added projectWeb for the Agent Surface knowledge tier.</item>
+  <item>RFC-0373: added projectServices for business service catalog projection.</item>
+</CHANGE_SUMMARY>
+*/
+
+import type {
+  SemanticOffer,
+  SemanticLocation,
+  SemanticPerson,
+  SemanticService,
+  SemanticWeb,
+} from "./models.ts";
+
+/**
+ * RFC-0148 privacy boundary. `public` projects to AI (llms) + JSON-LD; `pageMeta`
+ * is build-time only (e.g. legal-page dates → sitemap lastmod); `none` is never
+ * projected to any public output. `externalServices` (vendor names/addresses)
+ * and `compliance` (internal GoBD dates) are deliberately `none`.
+ */
+export const BUSINESS_DOMAIN_VISIBILITY = {
+  company: "public",
+  legal: "public",
+  contact: "public",
+  offer: "public",
+  service: "public",
+  location: "public",
+  web: "public",
+  people: "public",
+  trust: "public",
+  faq: "public",
+  meta: "pageMeta",
+  compliance: "none",
+  externalServices: "none",
+} as const;
+
+export type BusinessDomain = keyof typeof BUSINESS_DOMAIN_VISIBILITY;
+export type BusinessVisibility = (typeof BUSINESS_DOMAIN_VISIBILITY)[BusinessDomain];
+
+const PRICE_LABELS: ReadonlyArray<readonly [string, string]> = [
+  ["monthly", "Monthly"],
+  ["yearly", "Yearly"],
+  ["setup", "Setup"],
+];
+
+/** RFC-0147/RFC-0148: project the canonical offer (price + guarantees + growth modules + terms). */
+export function projectOffer(data: Record<string, unknown> | undefined): SemanticOffer | undefined {
+  if (!data) return undefined;
+
+  const price = (data["price"] ?? {}) as Record<string, unknown>;
+  const currency = typeof data["currency"] === "string" ? (data["currency"] as string) : undefined;
+  const prices = PRICE_LABELS.filter(
+    ([key]) => typeof price[key] === "string" && (price[key] as string).length > 0,
+  ).map(([key, label]) => ({
+    id: key,
+    label,
+    amount: price[key] as string,
+    ...(currency ? { currency } : {}),
+  }));
+
+  const rawGuarantees = (data["guarantees"] ?? {}) as Record<
+    string,
+    { label?: string; detail?: string } | undefined
+  >;
+  const guarantees = Object.entries(rawGuarantees)
+    .filter(([, g]) => g && typeof g.label === "string" && g.label.length > 0)
+    .map(([id, g]) => ({
+      id,
+      label: g!.label as string,
+      ...(g!.detail ? { detail: g!.detail } : {}),
+    }));
+
+  const rawGrowthModules = (data["growthModules"] ?? {}) as Record<
+    string,
+    { label?: string; description?: string; price?: string } | undefined
+  >;
+  const growthModules = Object.entries(rawGrowthModules)
+    .filter(([, m]) => m && typeof m.label === "string" && m.label.length > 0)
+    .map(([id, m]) => ({
+      id,
+      label: m!.label as string,
+      ...(m!.description ? { description: m!.description } : {}),
+      ...(m!.price ? { price: m!.price } : {}),
+    }));
+
+  const changePrice = typeof data["changePrice"] === "string" ? data["changePrice"] : undefined;
+  const hourlyRate = typeof data["hourlyRate"] === "string" ? data["hourlyRate"] : undefined;
+  const billingDay = typeof data["billingDay"] === "string" ? data["billingDay"] : undefined;
+  const rawCapacity = data["capacity"] as Record<string, unknown> | undefined;
+  const rawSlotRange = rawCapacity?.["slotRange"] as Record<string, unknown> | undefined;
+  const capacity =
+    rawCapacity &&
+    rawCapacity["enabled"] === true &&
+    typeof rawCapacity["timezone"] === "string" &&
+    typeof rawCapacity["startsAt"] === "string" &&
+    (rawCapacity["cadence"] === "monthly" || rawCapacity["cadence"] === "fixed-days") &&
+    typeof rawSlotRange?.["min"] === "number" &&
+    typeof rawSlotRange?.["max"] === "number" &&
+    typeof rawCapacity["maxSlotsPerWave"] === "number"
+      ? {
+          enabled: true,
+          timezone: rawCapacity["timezone"],
+          startsAt: rawCapacity["startsAt"],
+          cadence: rawCapacity["cadence"] as "monthly" | "fixed-days",
+          ...(typeof rawCapacity["cadenceDays"] === "number"
+            ? { cadenceDays: rawCapacity["cadenceDays"] }
+            : {}),
+          slotRange: { min: rawSlotRange["min"], max: rawSlotRange["max"] },
+          maxSlotsPerWave: rawCapacity["maxSlotsPerWave"],
+          availabilityStatus: "unknown" as const,
+        }
+      : undefined;
+
+  if (
+    prices.length === 0 &&
+    guarantees.length === 0 &&
+    growthModules.length === 0 &&
+    !capacity &&
+    !changePrice &&
+    !hourlyRate &&
+    !billingDay
+  )
+    return undefined;
+
+  return {
+    ...(prices.length ? { prices } : {}),
+    ...(guarantees.length ? { guarantees } : {}),
+    ...(growthModules.length ? { growthModules } : {}),
+    ...(capacity ? { capacity } : {}),
+    ...(changePrice ? { changePrice } : {}),
+    ...(hourlyRate ? { hourlyRate } : {}),
+    ...(billingDay ? { billingDay } : {}),
+  };
+}
+
+/** RFC-0200: project canonical Person records into SemanticPerson[]. Bio becomes
+ * the person description; `lifespan.died` drives `isDeceased` + `deathDate`;
+ * `affiliations`/`sameAs` are carried for governance derivation + entity grounding.
+ * Records without a name are dropped. Order preserved (loaders pre-sort by `order`). */
+export function projectPeople(
+  records: ReadonlyArray<Record<string, unknown>> | undefined,
+): SemanticPerson[] {
+  if (!records?.length) return [];
+  const people: SemanticPerson[] = [];
+  for (const r of records) {
+    const name = typeof r["name"] === "string" ? (r["name"] as string).trim() : "";
+    if (!name) continue;
+    const bio = typeof r["bio"] === "string" ? (r["bio"] as string).trim() : "";
+    const role = typeof r["role"] === "string" ? (r["role"] as string).trim() : "";
+    const affiliations = Array.isArray(r["affiliations"])
+      ? (r["affiliations"] as unknown[]).filter((a): a is string => typeof a === "string")
+      : [];
+    const sameAs = Array.isArray(r["sameAs"])
+      ? (r["sameAs"] as unknown[]).filter((s): s is string => typeof s === "string")
+      : [];
+    const lifespan = (r["lifespan"] ?? undefined) as Record<string, unknown> | undefined;
+    const born = lifespan?.["born"];
+    const died = lifespan?.["died"];
+
+    /* RFC-0512: map location string ("City, Region") → SemanticPerson.address. */
+    const locationRaw = typeof r["location"] === "string" ? (r["location"] as string).trim() : "";
+    let address: SemanticPerson["address"] | undefined;
+    if (locationRaw) {
+      const parts = locationRaw.split(",").map((s) => s.trim());
+      address = {
+        addressLocality: parts[0] ?? "",
+        ...(parts[1] ? { addressRegion: parts[1] } : {}),
+        addressCountry: "DE",
+      };
+    }
+
+    /* RFC-0512: map capabilities → SemanticPerson.knowsAbout. */
+    const capabilities = Array.isArray(r["capabilities"])
+      ? (r["capabilities"] as unknown[]).filter((c): c is string => typeof c === "string")
+      : [];
+
+    /* RFC-0512: map organization name → SemanticPerson.affiliation. */
+    const orgName =
+      typeof r["organizationName"] === "string" ? (r["organizationName"] as string).trim() : "";
+
+    people.push({
+      name,
+      ...(role ? { role } : {}),
+      ...(bio ? { description: bio } : {}),
+      ...(affiliations.length ? { affiliations } : {}),
+      ...(born != null ? { birthDate: String(born) } : {}),
+      ...(died != null ? { deathDate: String(died), isDeceased: true } : {}),
+      ...(sameAs.length ? { sameAs } : {}),
+      ...(address ? { address } : {}),
+      ...(capabilities.length ? { knowsAbout: capabilities } : {}),
+      ...(orgName ? { affiliation: { name: orgName } } : {}),
+    });
+  }
+  return people;
+}
+
+/** RFC-0148: project location (NAP locality/region/country + service area). */
+export function projectLocation(
+  data: Record<string, unknown> | undefined,
+): SemanticLocation | undefined {
+  if (!data) return undefined;
+
+  const place = (key: string): string | undefined => {
+    const node = data[key] as { name?: unknown } | undefined;
+    return typeof node?.name === "string" && node.name.length > 0 ? node.name : undefined;
+  };
+
+  const locality = place("city");
+  const region = place("region");
+  const country = place("country");
+  const serviceAreaRaw = data["serviceArea"];
+  const serviceArea = Array.isArray(serviceAreaRaw)
+    ? serviceAreaRaw.filter((s): s is string => typeof s === "string" && s.length > 0)
+    : undefined;
+
+  if (!locality && !region && !country && !(serviceArea && serviceArea.length)) return undefined;
+  return {
+    ...(locality ? { locality } : {}),
+    ...(region ? { region } : {}),
+    ...(country ? { country } : {}),
+    ...(serviceArea && serviceArea.length ? { serviceArea } : {}),
+  };
+}
+
+/** RFC-0373: project business service catalog entries into SemanticService[].
+ * Records without a name are dropped. Order preserved (loaders pre-sort by `order`). */
+export function projectServices(
+  records: ReadonlyArray<Record<string, unknown>> | undefined,
+): SemanticService[] {
+  if (!records?.length) return [];
+  const services: SemanticService[] = [];
+  for (const r of records) {
+    const name = typeof r["name"] === "string" ? (r["name"] as string).trim() : "";
+    if (!name) continue;
+    const slug = typeof r["slug"] === "string" ? (r["slug"] as string) : "";
+    const description =
+      typeof r["description"] === "string" ? (r["description"] as string).trim() : "";
+    services.push({
+      id: slug || name,
+      name,
+      ...(description ? { description } : {}),
+    });
+  }
+  return services;
+}
+
+/**
+ * RFC-0287: project the business web/domain identity record (business/{lang}/web.md
+ * — primaryUrl, statusUrl, domains.{primary,german}). A thin, faithful passthrough of
+ * an already-validated, stable cross-app shape — not a generic business-file dump.
+ */
+export function projectWeb(data: Record<string, unknown> | undefined): SemanticWeb | undefined {
+  if (!data) return undefined;
+
+  const primaryUrl = typeof data["primaryUrl"] === "string" ? data["primaryUrl"] : undefined;
+  const statusUrl = typeof data["statusUrl"] === "string" ? data["statusUrl"] : undefined;
+  const domainsRaw = (data["domains"] ?? {}) as Record<string, unknown>;
+  const primary = typeof domainsRaw["primary"] === "string" ? domainsRaw["primary"] : undefined;
+  const german = typeof domainsRaw["german"] === "string" ? domainsRaw["german"] : undefined;
+
+  if (!primaryUrl && !statusUrl && !primary && !german) return undefined;
+  return {
+    ...(primaryUrl ? { primaryUrl } : {}),
+    ...(statusUrl ? { statusUrl } : {}),
+    ...(primary || german
+      ? { domains: { ...(primary ? { primary } : {}), ...(german ? { german } : {}) } }
+      : {}),
+  };
+}

package/src/share/semantic/derived-prices-loader.ts

@@ -0,0 +1,36 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Node-only loader for derived-prices.generated.json (RFC-0767). Reads the file from process.cwd()/src/derived-prices.generated.json and returns null on ENOENT. NOT exported from the semantic barrel — uses node:fs and would pollute client bundles.</purpose>
+<non-goals>
+  <item>Does not parse or validate the JSON shape — just reads and JSON.parse.</item>
+  <item>Does not cache — callers are responsible for calling once and passing the result.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0767: relocated loadDerivedPrices from packages/ui to packages/share to break circular dependency. Node-only subpath export.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { DerivedPriceEntry } from "./price-marker-resolver.ts";
+
+export function loadDerivedPrices(
+  cwd: string = process.cwd(),
+): Record<string, DerivedPriceEntry[]> | null {
+  const filePath = join(cwd, "src", "derived-prices.generated.json");
+  let raw: string;
+  try {
+    raw = readFileSync(filePath, "utf-8");
+  } catch (err: unknown) {
+    if (err instanceof Error && (err as NodeJS.ErrnoException).code === "ENOENT") {
+      console.warn(
+        `[derived-prices] ${filePath} not found — currency-aware price variants will not render. ` +
+          `Run: pnpm exec werkstatt run derived-prices.materialize --site <siteId>`,
+      );
+      return null;
+    }
+    throw err;
+  }
+  return JSON.parse(raw) as Record<string, DerivedPriceEntry[]>;
+}