@warpgogol/werkstatt-shared 0.8.0 → 0.8.2

package/src/share/middleware/tests/access-protection.test.ts

@@ -0,0 +1,123 @@
+/*
+<MODULE_CONTRACT>
+  <purpose>RFC-0899: Unit tests for access protection middleware logic — constant-time comparison, host matching, PIN gating.</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0899: Initial middleware unit tests.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { describe, expect, it, vi } from "vitest";
+
+const mockEnv: Record<string, unknown> = {};
+vi.mock("cloudflare:workers", () => ({
+  env: mockEnv,
+}));
+vi.mock("astro:middleware", () => ({
+  defineMiddleware: (handler: unknown) => handler,
+}));
+
+describe("RFC-0899: access protection middleware", () => {
+  async function loadMiddleware() {
+    return (await import("../access-protection")).accessProtectionMiddleware as (
+      context: unknown,
+      next: () => Promise<Response>,
+    ) => Promise<Response>;
+  }
+
+  function makeContext(host: string, authHeader?: string) {
+    const headers = new Map<string, string>();
+    headers.set("host", host);
+    if (authHeader) headers.set("authorization", authHeader);
+    return {
+      request: {
+        headers: {
+          get: (name: string) => headers.get(name.toLowerCase()) ?? null,
+        },
+      },
+    };
+  }
+
+  async function runMiddleware(
+    handler: (context: unknown, next: () => Promise<Response>) => Promise<Response>,
+    host: string,
+    authHeader?: string,
+  ): Promise<Response & { _nextCalled: boolean }> {
+    let nextCalled = false;
+    const nextResponse = new Response("page content", { status: 200 });
+    const result = await handler(makeContext(host, authHeader), async () => {
+      nextCalled = true;
+      return nextResponse;
+    });
+    return Object.assign(result, { _nextCalled: nextCalled });
+  }
+
+  it("passes through for main domain (no dev/alt prefix)", async () => {
+    mockEnv.ACCESS_PIN = "1234";
+    const handler = await loadMiddleware();
+    const res = await runMiddleware(handler, "example.com");
+    expect(res._nextCalled).toBe(true);
+    expect(res.status).toBe(200);
+  });
+
+  it("returns 401 for dev.* without auth header when PIN is set", async () => {
+    mockEnv.ACCESS_PIN = "1234";
+    const handler = await loadMiddleware();
+    const res = await runMiddleware(handler, "dev.example.com");
+    expect(res._nextCalled).toBe(false);
+    expect(res.status).toBe(401);
+    expect(res.headers.get("WWW-Authenticate")).toBe('Basic realm="Staging Access"');
+    expect(res.headers.get("X-Robots-Tag")).toBe("noindex, nofollow, noai, noimageai");
+  });
+
+  it("returns 401 for alt.* without auth header when PIN is set", async () => {
+    mockEnv.ACCESS_PIN = "1234";
+    const handler = await loadMiddleware();
+    const res = await runMiddleware(handler, "alt.example.com");
+    expect(res._nextCalled).toBe(false);
+    expect(res.status).toBe(401);
+  });
+
+  it("passes through dev.* with correct Basic Auth", async () => {
+    mockEnv.ACCESS_PIN = "1234";
+    const expected = `Basic ${btoa("warp:1234")}`;
+    const handler = await loadMiddleware();
+    const res = await runMiddleware(handler, "dev.example.com", expected);
+    expect(res._nextCalled).toBe(true);
+    expect(res.status).toBe(200);
+    expect(res.headers.get("X-Robots-Tag")).toBe("noindex, nofollow, noai, noimageai");
+  });
+
+  it("returns 401 for dev.* with wrong PIN", async () => {
+    mockEnv.ACCESS_PIN = "1234";
+    const wrong = `Basic ${btoa("warp:9999")}`;
+    const handler = await loadMiddleware();
+    const res = await runMiddleware(handler, "dev.example.com", wrong);
+    expect(res._nextCalled).toBe(false);
+    expect(res.status).toBe(401);
+  });
+
+  it("passes through dev.* when PIN is not set (no env var)", async () => {
+    delete mockEnv.ACCESS_PIN;
+    const handler = await loadMiddleware();
+    const res = await runMiddleware(handler, "dev.example.com");
+    expect(res._nextCalled).toBe(true);
+    expect(res.status).toBe(200);
+    expect(res.headers.get("X-Robots-Tag")).toBe("noindex, nofollow, noai, noimageai");
+  });
+
+  it("passes through alt.* when PIN env is undefined", async () => {
+    mockEnv.ACCESS_PIN = undefined;
+    const handler = await loadMiddleware();
+    const res = await runMiddleware(handler, "alt.example.com");
+    expect(res._nextCalled).toBe(true);
+    expect(res.headers.get("X-Robots-Tag")).toBe("noindex, nofollow, noai, noimageai");
+  });
+
+  it("does not set X-Robots-Tag on main domain", async () => {
+    mockEnv.ACCESS_PIN = "1234";
+    const handler = await loadMiddleware();
+    const res = await runMiddleware(handler, "example.com");
+    expect(res.headers.get("X-Robots-Tag")).toBe(null);
+  });
+});

package/src/share/page.ts

@@ -44,7 +44,7 @@ export interface PageEntry {
 }
 
 export interface BlockEntry {
-  id?: string;
+  id: string;
   type?: string; // CMS-facing archetype slug — validated by page.block.validate
   use?: string; // PlanetName or MoonName — normalized from type for internal resolution
   props: Record<string, unknown>;
@@ -75,7 +75,7 @@ export interface ShellConfig {
  * All blocks in ResolvedPage.blocks passed visibility — invisible blocks are dropped.
  */
 export interface ResolvedBlock {
-  /** Stable kebab-case block id from the content entry (null if not declared). */
+  /** Stable kebab-case block id from the content entry. Mandatory for content blocks (RFC-0914); null only for shell blocks injected by the pipeline. */
   readonly id: string | null;
   /** The PlanetName or MoonName identifying this block's archetype. */
   readonly planetName: string;
@@ -121,6 +121,8 @@ export interface SectionProps {
   defaultLanguageCode: string;
   /** Zero-padded section index (01, 02, ...) for anchors and styling */
   sectionNumber: string;
+  /** RFC-0914: Stable kebab-case block id from content entry, used as HTML id */
+  blockId: string;
   /** Optional link registry for CTA/link resolution */
   linkRegistry?: Record<string, string | null>;
   /** Complete block.props as declared in page frontmatter */

package/src/share/routes/template-filter.ts

@@ -0,0 +1,36 @@
+/*
+<MODULE_CONTRACT>
+<purpose>
+RFC-0917 canonical placeholder route template filter. Detects Astro dynamic
+route templates (e.g. `[slug]`, `[version]`) that are expanded by dedicated
+route generators, not actual pages. All system.md consumers MUST import this
+utility instead of reimplementing the bracket-detection check inline.
+</purpose>
+<non-goals>
+  <item>Do not expand or resolve placeholder templates — only detect them.</item>
+  <item>Do not validate route syntax — bracket presence is the only signal.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0917: Initial creation — centralize placeholder route template filtering.</item>
+</CHANGE_SUMMARY>
+*/
+
+/**
+ * Returns `true` if any route value in the given routes map contains
+ * `[` or `]` characters, indicating an Astro dynamic route template
+ * (e.g. `nachweis/[slug]`, `verify/[version]`).
+ *
+ * Returns `false` for `undefined`, `null`, or empty routes — safe default
+ * that avoids false positives when routes are missing or not yet resolved.
+ *
+ * Canonical utility (RFC-0917). All `system.md` consumers
+ * MUST import from `@warpgogol/werkstatt-shared/share/routes/template-filter`.
+ * Enforcement: `utility.provenance.validate` (RFC-0916).
+ */
+export function hasPlaceholderRoutes(routes?: Record<string, string> | null): boolean {
+  if (!routes) return false;
+  return Object.values(routes).some(
+    (slug) => typeof slug === "string" && (slug.includes("[") || slug.includes("]")),
+  );
+}

package/src/share/routes/tests/template-filter.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from "vitest";
+import { hasPlaceholderRoutes } from "../template-filter.ts";
+
+describe("hasPlaceholderRoutes", () => {
+  it("returns true for routes containing [slug]", () => {
+    expect(hasPlaceholderRoutes({ de: "nachweis/[slug]" })).toBe(true);
+  });
+
+  it("returns true for routes containing [version]", () => {
+    expect(hasPlaceholderRoutes({ de: "verify/[version]" })).toBe(true);
+  });
+
+  it("returns true for routes containing [...path] (rest params)", () => {
+    expect(hasPlaceholderRoutes({ de: "docs/[...path]" })).toBe(true);
+  });
+
+  it("returns true for mixed routes (some plain, some placeholder)", () => {
+    expect(hasPlaceholderRoutes({ de: "home", en: "blog/[slug]" })).toBe(true);
+  });
+
+  it("returns false for plain routes without brackets", () => {
+    expect(hasPlaceholderRoutes({ de: "home", en: "about" })).toBe(false);
+  });
+
+  it("returns false for undefined routes", () => {
+    expect(hasPlaceholderRoutes(undefined)).toBe(false);
+  });
+
+  it("returns false for null routes", () => {
+    expect(hasPlaceholderRoutes(null)).toBe(false);
+  });
+
+  it("returns false for empty routes object", () => {
+    expect(hasPlaceholderRoutes({})).toBe(false);
+  });
+
+  it("returns false when route values are non-string", () => {
+    expect(hasPlaceholderRoutes({ de: 123 as unknown as string })).toBe(false);
+  });
+});

package/src/share/scripts/lenis.ts

@@ -79,6 +79,7 @@ export async function initLenis(
             offset: -headerOffset,
             immediate: prefersReducedMotion,
           });
+          history.replaceState(null, "", href);
         }
       }
     }

package/src/share/semantic/block-extractors/index.ts

@@ -500,3 +500,27 @@ for (const blockType of PASSPORT_NOOP_TYPES) {
     },
   });
 }
+
+// ---------------------------------------------------------------------------
+// Site-specific block types that have no semantic text to extract but must be
+// registered so page.blocks.extract.validate does not fail.
+// ---------------------------------------------------------------------------
+const SITE_NOOP_TYPES = [
+  "nachweis-list",
+  "nachweis-detail",
+  "nachweis-verify",
+  "gratitude",
+  "open-source-registry",
+  "mountain-journey",
+  "dynamic-status-block",
+  "service-metadata-block",
+] as const;
+
+for (const blockType of SITE_NOOP_TYPES) {
+  BLOCK_EXTRACTORS.register<Record<string, unknown>>({
+    blockType,
+    extract() {
+      return { heading: "" };
+    },
+  });
+}

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

@@ -10,6 +10,7 @@
 <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>
+  <item>RFC-0912: extract seo.videoObject opt-in from block props and attach VideoSeoData to SemanticBlock.video.</item>
 </CHANGE_SUMMARY>
 */
 
@@ -22,6 +23,7 @@ import type {
   SemanticPageModel,
   SemanticPageType,
   SemanticPerson,
+  VideoSeoData,
 } from "./models.ts";
 import { BLOCK_EXTRACTORS } from "./block-extraction.ts";
 import "./block-extractors/index.ts";
@@ -132,6 +134,31 @@ async function resolveFaqEntries(
   return faqEntries;
 }
 
+/** RFC-0912: extract video SEO data from block props when seo.videoObject opt-in is present. */
+function extractVideoSeoData(props: Record<string, unknown>): VideoSeoData | undefined {
+  const seo = props["seo"];
+  if (!seo || typeof seo !== "object") return undefined;
+  const seoRecord = seo as Record<string, unknown>;
+  if (seoRecord["videoObject"] !== true) return undefined;
+  const name = seoRecord["name"];
+  const description = seoRecord["description"];
+  const uploadDate = seoRecord["uploadDate"];
+  if (
+    typeof name !== "string" ||
+    typeof description !== "string" ||
+    typeof uploadDate !== "string"
+  ) {
+    return undefined;
+  }
+  // The manifest data (posterUrl, durationSec, contentUrl) is populated by the
+  // render layer when the variant manifest is available. At build-page time we
+  // carry the seo fields; the render layer fills in the manifest data.
+  return {
+    seo: { name, description, uploadDate },
+    manifest: { posterUrl: "", contentUrl: "" },
+  };
+}
+
 /** RFC-0372: extract semantic text from declared blocks into SemanticBlock[]. */
 function extractContentBlocks(
   blocks: Array<Record<string, unknown>>,
@@ -140,7 +167,12 @@ function extractContentBlocks(
   const result: SemanticBlock[] = [];
   for (const block of blocks) {
     const blockType = String(block["type"] ?? "");
-    const blockId = String(block["id"] ?? `block-${result.length}`);
+    const blockId = block["id"];
+    if (typeof blockId !== "string" || !blockId) {
+      throw new Error(
+        `[extractContentBlocks] Block #${result.length} in page ${ctx.pageId} (${ctx.lang}) is missing required \`id\` field. Run \`block.id.generate\` to backfill.`,
+      );
+    }
     if (!blockType) continue;
     const extractor = BLOCK_EXTRACTORS.get(blockType);
     if (!extractor) continue;
@@ -156,6 +188,12 @@ function extractContentBlocks(
       items: extracted.items,
       extractedAt: new Date().toISOString(),
       extractorVersion: "1.0.0",
+      // RFC-0912: attach video SEO data when the block has seo.videoObject opt-in.
+      ...((block["props"] ?? block) &&
+      typeof (block["props"] ?? block) === "object" &&
+      extractVideoSeoData((block["props"] ?? block) as Record<string, unknown>)
+        ? { video: extractVideoSeoData((block["props"] ?? block) as Record<string, unknown>) }
+        : {}),
     });
   }
   return result;

package/src/share/semantic/extract.ts

@@ -7,6 +7,7 @@
 </MODULE_CONTRACT>
 <CHANGE_SUMMARY>
   <item>RFC-0133: backfilled MODULE_MAP and CHANGE_SUMMARY markers for compass.validate compliance.</item>
+  <item>RFC-0915: removed custom slugify() — replaced by slugId from @warpgogol/werkstatt-shared/share/slug.</item>
 </CHANGE_SUMMARY>
 */
 
@@ -16,17 +17,6 @@ export function normalizeWhitespace(value: string): string {
   return value.replace(/\s+/g, " ").trim();
 }
 
-export function slugify(value: string): string {
-  return (
-    value
-      .toLowerCase()
-      .normalize("NFKD")
-      .replace(/[\u0300-\u036f]/g, "")
-      .replace(/[^a-z0-9]+/g, "-")
-      .replace(/^-+|-+$/g, "") || "entity"
-  );
-}
-
 export type MarkdownSection = {
   heading: string;
   body: string;
@@ -62,6 +52,90 @@ export function extractParagraphs(markdown: string): string[] {
     .filter(Boolean);
 }
 
+const SENTENCE_ABBREVIATIONS: Record<string, string[]> = {
+  de: [
+    "z.B.",
+    "z. B.",
+    "z.",
+    "etc.",
+    "Nr.",
+    "Abs.",
+    "§",
+    "S.",
+    "ca.",
+    "u.a.",
+    "u. a.",
+    "u.",
+    "vgl.",
+    "bspw.",
+  ],
+  uk: ["т.д.", "т.п.", "п.", "ст.", "див.", "пор.", "напр.", "ім.", "о."],
+  en: ["e.g.", "i.e.", "etc.", "vs.", "Mr.", "Mrs.", "Dr.", "Inc.", "Ltd."],
+};
+
+function escapeRegex(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function buildAbbreviationPattern(abbreviations: string[]): RegExp | undefined {
+  if (abbreviations.length === 0) return undefined;
+  const sorted = [...abbreviations].sort((a, b) => b.length - a.length);
+  return new RegExp(`(?:^|[^a-zA-Zа-яА-ЯёЁїЇіІєЄäöüÄÖÜß])(${sorted.map(escapeRegex).join("|")})$`);
+}
+
+export function splitSentences(text: string, locale: string = "en"): string[] {
+  const normalized = text.trim();
+  if (!normalized) return [];
+
+  const abbreviations = SENTENCE_ABBREVIATIONS[locale] ?? SENTENCE_ABBREVIATIONS.en;
+  const abbrevPattern = buildAbbreviationPattern(abbreviations);
+
+  const sentences: string[] = [];
+  let current = "";
+
+  const chars = [...normalized];
+  for (let i = 0; i < chars.length; i++) {
+    const char = chars[i];
+    current += char;
+
+    if (char !== "." && char !== "!" && char !== "?") continue;
+
+    const nextChar = chars[i + 1];
+    if (nextChar === undefined) {
+      sentences.push(current.trim());
+      current = "";
+      continue;
+    }
+
+    if (nextChar !== " " && nextChar !== "\n" && nextChar !== "\t") continue;
+
+    const beforeAbbrCheck = current.trimEnd();
+
+    if (abbrevPattern && abbrevPattern.test(beforeAbbrCheck)) continue;
+
+    // Skip numbered list markers (e.g., "1. ", "2. ") — a period after
+    // digits is a list marker, not a sentence boundary. After normalizeWhitespace
+    // newlines are spaces, so we check the token before the period.
+    const beforePeriod = current.slice(0, -1);
+    const lastSpaceIdx = Math.max(beforePeriod.lastIndexOf(" "), beforePeriod.lastIndexOf("\n"));
+    const tokenBeforePeriod = beforePeriod.slice(lastSpaceIdx + 1).trim();
+    if (/^\d+$/.test(tokenBeforePeriod)) continue;
+
+    const afterWhitespace = chars
+      .slice(i + 1)
+      .join("")
+      .match(/^\s*([A-ZÄÖÜА-ЯЁЇІЄ])/);
+    if (!afterWhitespace) continue;
+
+    sentences.push(current.trim());
+    current = "";
+  }
+
+  if (current.trim()) sentences.push(current.trim());
+
+  return sentences.filter(Boolean);
+}
+
 export function extractListFacts(markdown: string): string[] {
   return markdown
     .split("\n")

package/src/share/semantic/ids.ts

@@ -8,6 +8,7 @@
 </MODULE_CONTRACT>
 <CHANGE_SUMMARY>
   <item>Moved from app semantic/ids to packages/share/src/semantic/ids.ts — framework-agnostic, reusable across all apps.</item>
+  <item>RFC-0910: add canonicalRootUrl — unprefixed root URL for entity identity (Organization.url, WebSite.url).</item>
 </CHANGE_SUMMARY>
 */
 
@@ -27,6 +28,18 @@ export function toAbsoluteUrl(baseUrl: string, path: string): string {
   return new URL(path, `${baseUrl}/`).toString();
 }
 
+/**
+ * RFC-0910: produce the canonical root URL for entity identity.
+ *
+ * The entity root URL is language-independent — it is always `https://site/`
+ * regardless of the default language. This contrasts with page URLs, which
+ * are language-prefixed for non-default languages and unprefixed for the
+ * default language per RFC-0160.
+ */
+export function canonicalRootUrl(baseUrl: string): string {
+  return new URL("/", `${baseUrl}/`).toString();
+}
+
 export function toPathname(url: string): string {
   return new URL(url).pathname;
 }

package/src/share/semantic/jsonld/organization.ts

@@ -97,5 +97,25 @@ export function buildOrganizationNode(context: JsonLdContext): JsonLdNode {
       ? { logo: { "@type": "ImageObject", url: page.organization.logo } }
       : {}),
     ...(page.organization.image ? { image: page.organization.image } : {}),
+    ...(page.organization.offer?.prices?.length
+      ? { priceRange: buildPriceRange(page.organization.offer.prices) }
+      : {}),
   };
 }
+
+function buildPriceRange(prices: Array<{ amount: string; currency?: string }>): string {
+  const numericAmounts = prices
+    .map((p) => Number.parseFloat(p.amount))
+    .filter((n) => !Number.isNaN(n));
+  if (numericAmounts.length === 0) return "";
+  const min = Math.min(...numericAmounts);
+  const max = Math.max(...numericAmounts);
+  const currency = prices.find((p) => p.currency)?.currency;
+  const formatAmount = (n: number) => (Number.isInteger(n) ? String(n) : n.toFixed(2));
+  if (min === max) {
+    return currency ? `${formatAmount(min)} ${currency}` : formatAmount(min);
+  }
+  return currency
+    ? `${formatAmount(min)}–${formatAmount(max)} ${currency}`
+    : `${formatAmount(min)}–${formatAmount(max)}`;
+}

package/src/share/semantic/jsonld/video.ts

@@ -0,0 +1,56 @@
+/*
+<MODULE_CONTRACT>
+<purpose>RFC-0912: builds VideoObject JSON-LD nodes from SemanticBlock.video data for opted-in content videos. Reads variant-manifest-derived data populated by buildSemanticPageModelWith.</purpose>
+<non-goals>
+  <item>Do not read the variant manifest directly — buildSemanticPageModelWith populates SemanticBlock.video before buildJsonLd runs.</item>
+  <item>Do not emit VideoObject for blocks without the seo.videoObject opt-in.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0912: initial implementation.</item>
+</CHANGE_SUMMARY>
+*/
+
+import type { JsonLdContext } from "./context.ts";
+import type { JsonLdNode } from "./types.ts";
+
+function formatDuration(seconds: number): string {
+  const totalSec = Math.round(seconds);
+  const hours = Math.floor(totalSec / 3600);
+  const minutes = Math.floor((totalSec % 3600) / 60);
+  const secs = totalSec % 60;
+  const parts = ["PT"];
+  if (hours > 0) parts.push(`${hours}H`);
+  if (minutes > 0) parts.push(`${minutes}M`);
+  parts.push(`${secs}S`);
+  return parts.join("");
+}
+
+export function buildVideoObjectNodes(context: JsonLdContext): JsonLdNode[] {
+  const { page, webpageId } = context;
+  const nodes: JsonLdNode[] = [];
+
+  for (const block of page.blocks) {
+    if (!block.video) continue;
+
+    const { seo, manifest } = block.video;
+    const nodeId = `${webpageId.replace("#/schema/webpage", "#/schema/video")}/${block.id}`;
+
+    const node: JsonLdNode = {
+      "@type": "VideoObject",
+      "@id": nodeId,
+      name: seo.name,
+      description: seo.description,
+      uploadDate: seo.uploadDate,
+      thumbnailUrl: manifest.posterUrl,
+      contentUrl: manifest.contentUrl,
+      ...(manifest.durationSec != null
+        ? { duration: formatDuration(manifest.durationSec) }
+        : {}),
+    };
+
+    nodes.push(node);
+  }
+
+  return nodes;
+}

package/src/share/semantic/jsonld/webpage.ts

@@ -90,7 +90,7 @@ export function buildWebPageNode(context: JsonLdContext): JsonLdNode {
       ? {
           speakable: {
             "@type": "SpeakableSpecification",
-            cssSelector: page.lead ? ["h1", ".section-header__lead"] : ["h1"],
+            cssSelector: page.lead ? ["h1", ".section-header__subheading"] : ["h1"],
           },
         }
       : {}),

package/src/share/semantic/jsonld.ts

@@ -8,6 +8,7 @@
 </MODULE_CONTRACT>
 <CHANGE_SUMMARY>
   <item>Added initiative list graph node, breadcrumb fallback, and shared dedupe utility.</item>
+  <item>RFC-0912: added VideoObject node composition for opted-in content video blocks.</item>
 </CHANGE_SUMMARY>
 */
 
@@ -22,12 +23,14 @@ import { buildPersonNodes } from "./jsonld/person.ts";
 import { buildServiceNodes } from "./jsonld/service.ts";
 import { dedupeGraph } from "./jsonld/shared.ts";
 import type { JsonLdDocument } from "./jsonld/types.ts";
+import { buildVideoObjectNodes } from "./jsonld/video.ts";
 import { buildWebPageNode } from "./jsonld/webpage.ts";
 import { buildWebSiteNode } from "./jsonld/website.ts";
 import type { SemanticPageModel } from "./models.ts";
 
 export type { JsonLdDocument } from "./jsonld/types.ts";
 export type { JsonLdContext } from "./jsonld/context.ts";
+export { buildVideoObjectNodes } from "./jsonld/video.ts";
 
 export function buildJsonLd(page: SemanticPageModel): JsonLdDocument {
   const context = createJsonLdContext(page);
@@ -68,6 +71,8 @@ export function buildJsonLd(page: SemanticPageModel): JsonLdDocument {
       ...(collectionListNode ? [collectionListNode] : []),
       ...(articleNode ? [articleNode] : []),
       ...(breadcrumbNode ? [breadcrumbNode] : []),
+      // RFC-0912: VideoObject nodes for opted-in content video blocks.
+      ...buildVideoObjectNodes(context),
       // RFC-0512: extra nodes from team profile pages (SoftwareApplication, CollectionPage).
       ...(page.extraGraphNodes ?? []),
     ]),

package/src/share/semantic/models.ts

@@ -12,6 +12,7 @@
   <item>RFC-0490: Added "collection" to the SemanticPageType closed enum.</item>
   <item>RFC-0508: Added "participant" to the SemanticPageType closed enum.</item>
   <item>RFC-0372: Unified SemanticBlock type replaces SemanticAnswerBlock + SemanticContentBlock; SemanticPageModel.blocks replaces answerBlocks/contentBlocks/bodyText.</item>
+  <item>RFC-0912: Added VideoSeoData type and optional SemanticBlock.video field for opted-in content video structured data.</item>
 </CHANGE_SUMMARY>
 */
 
@@ -59,6 +60,12 @@ export type SemanticBreadcrumb = {
  * Every block in a SemanticPageModel is represented by this single type, regardless of
  * whether it was derived from prose parsing or frontmatter block extraction.
  */
+/** RFC-0912: video SEO data populated by buildSemanticPageModelWith for opted-in content video blocks. */
+export type VideoSeoData = {
+  seo: { name: string; description: string; uploadDate: string };
+  manifest: { posterUrl: string; durationSec?: number; contentUrl: string };
+};
+
 export type SemanticBlock = {
   /** Stable id from frontmatter block.id (required) or slugified heading for prose-derived blocks. */
   id: string;
@@ -77,6 +84,8 @@ export type SemanticBlock = {
   /** Extractor metadata (absent for prose-derived blocks). */
   extractedAt?: string;
   extractorVersion?: string;
+  /** RFC-0912: video SEO data for opted-in content video blocks (seo.videoObject: true). Populated by buildSemanticPageModelWith from the variant manifest. */
+  video?: VideoSeoData;
 };
 
 /* RFC-0142: per-page llms inclusion depth. */

package/src/share/semantic/organization-profile.ts

@@ -8,10 +8,11 @@
 </MODULE_CONTRACT>
 <CHANGE_SUMMARY>
   <item>RFC-0148: extracted the shared org-profile assembler from the disk + Astro builders.</item>
+  <item>RFC-0910: Organization.url uses canonicalRootUrl (unprefixed root) instead of language-prefixed path.</item>
 </CHANGE_SUMMARY>
 */
 
-import { getBaseUrl, toAbsoluteUrl } from "./ids.ts";
+import { canonicalRootUrl, getBaseUrl, toAbsoluteUrl } from "./ids.ts";
 import type {
   SemanticInitiative,
   SemanticLocation,
@@ -104,7 +105,7 @@ export function buildOrganizationProfile(input: OrganizationProfileInput): Seman
     name: input.brandName,
     legalName: input.legalName,
     description: input.description,
-    url: toAbsoluteUrl(baseUrl, `/${input.lang}/`),
+    url: canonicalRootUrl(baseUrl),
     foundingYear: input.foundingYear,
     email: input.email,
     registration: input.registration,