@tokenoftrust/storefront-runner 2.0.16 → 2.0.18

package/packages/public-runtime/tests/conformance/fake-destination.ts

@@ -0,0 +1,402 @@
+/**
+ * Test-only destination for integration conformance suites.
+ *
+ * This is deliberately not a `fetch` wrapper and accepts no URL, credential,
+ * tenant, or environment configuration. A caller hands an already-built
+ * delivery attempt to `deliver`; the harness records a redacted snapshot and
+ * returns the next planned result without opening a socket or reproducing a
+ * delivery runtime.
+ */
+
+export const FAKE_DESTINATION_ID = "fixture:integration-conformance" as const;
+export const FAKE_REDACTION_MARKER = "«redacted»" as const;
+
+type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue };
+
+export type FakeDestinationOutcome =
+  | { kind: "success"; status: 200 | 201 | 202 | 204 }
+  | { kind: "retryable-failure"; status: 408 | 425 | 429 | 500 | 502 | 503 | 504; retryAfterMs?: number }
+  | { kind: "terminal-failure"; status: 400 | 401 | 403 | 404 | 409 | 410 | 422 };
+
+export interface FakeDeliveryAttempt {
+  deliveryId: string;
+  eventType: string;
+  payload: unknown;
+  headers?: Readonly<Record<string, string>>;
+}
+
+export interface FakeDeliveryReceipt {
+  receiptId: string;
+  attemptNumber: number;
+  destination: typeof FAKE_DESTINATION_ID;
+  deliveryId: string;
+  eventType: string;
+  request: {
+    payload: JsonValue;
+    headers: Readonly<Record<string, string>>;
+  };
+  outcome: FakeDestinationOutcome;
+}
+
+export interface FakeDestination {
+  readonly id: typeof FAKE_DESTINATION_ID;
+  deliver(attempt: FakeDeliveryAttempt): Promise<FakeDeliveryReceipt>;
+  receipts(): readonly FakeDeliveryReceipt[];
+  assertReceipts(expected: readonly FakeDeliveryReceipt[]): void;
+}
+
+const UNSAFE_KEY = /(authorization|cookie|credential|password|private.?key|secret|signature|token|api.?key|email|phone|mobile|telephone|address|street|city|postal|zip|first.?name|last.?name|full.?name|customer.?name|recipient.?name|date.?of.?birth|birth.?date|dob|social.?security|ssn|card|cvv|custom.?html|javascript|script|code|template|loader|data.?layer|gtm|url|uri|endpoint|webhook)/i;
+const AUTH_VALUE = /\b(?:basic|bearer)\s+[^\s,;]+/i;
+const EMAIL_VALUE = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i;
+const PHONE_VALUE = /(?:^|\D)(?:\+?1[\s().-]*)?(?:\d[\s().-]*){7,15}(?:\D|$)/;
+const SSN_VALUE = /(?:^|\D)\d{3}[ -]?\d{2}[ -]?\d{4}(?:\D|$)/;
+const PAYMENT_NUMBER_VALUE = /(?:^|\D)(?:\d[ -]?){13,19}(?:\D|$)/;
+const GOVERNMENT_ID_VALUE = /(?:^|\D)(?:\d{2}-\d{7}|[A-Z]\d{7,8})(?:\D|$)/i;
+const ADDRESS_VALUE = /\b\d{1,6}\s+[A-Z0-9][A-Z0-9 .'-]{1,80}\s(?:street|st|road|rd|avenue|ave|boulevard|blvd|lane|ln|drive|dr|court|ct|way|parkway|pkwy)\b/i;
+const PERSON_NAME_VALUE = /^(?:[A-Z][A-Z'-]{1,30})\s+(?:[A-Z][A-Z'-]{1,30})(?:\s+[A-Z][A-Z'-]{1,30}){0,2}$/i;
+const TECHNICAL_IDENTIFIER_PREFIXES = new Set([
+  "delivery", "offline", "unexpected", "storefront", "order", "integration",
+  "event", "attempt", "receipt", "fixture", "synthetic", "fake", "test",
+]);
+const IDENTIFIER_WORD = /^[A-Z]{2,30}$/i;
+const HYPHENATED_ADDRESS_VALUE = /(?:^|-)\d{1,6}(?:-[A-Z0-9]+){1,5}-(?:street|st|road|rd|avenue|ave|boulevard|blvd|lane|ln|drive|dr|court|ct|way|parkway|pkwy)(?:-|$)/i;
+const LIVE_URL_VALUE = /\b(?:https?|wss?):\/\//i;
+const CODE_VALUE = /(?:<\/?[a-z][^>]*>|javascript\s*:|data\s*:\s*(?:text\/html|application\/javascript)|\b(?:eval|Function|import|require|alert|fetch|XMLHttpRequest)\s*\(|\b(?:document|window|globalThis|console|dataLayer)\s*\.|\bGTM-[A-Z0-9-]+\b|=>|\{\{[^}]+\}\})/i;
+const CREDENTIAL_VALUE = /(-----BEGIN [A-Z ]*PRIVATE KEY-----|\bAKIA[0-9A-Z]{16}\b)/i;
+const SAFE_IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+const SAFE_HEADERS = new Set(["content-type", "idempotency-key", "x-delivery-attempt", "x-event-type"]);
+const ALLOWED_CONFIG_KEYS = new Set(["outcomes"]);
+const ALLOWED_ATTEMPT_KEYS = new Set(["deliveryId", "eventType", "payload", "headers"]);
+const MAX_SAFE_FIXTURE_NUMBER = 999_999;
+const MAX_RETRY_AFTER_MS = 86_400_000;
+const INTERNAL_REFUSALS = new WeakSet<object>();
+
+function fail(message: string): never {
+  const error = new Error(`Fake destination configuration refused: ${message}`);
+  INTERNAL_REFUSALS.add(error);
+  throw error;
+}
+
+function inspect<T>(label: string, operation: () => T): T {
+  try {
+    return operation();
+  } catch (error) {
+    if (error !== null && typeof error === "object" && INTERNAL_REFUSALS.has(error)) throw error;
+    fail(`${label} could not be safely inspected`);
+  }
+}
+
+function isArray(value: unknown, label: string): value is unknown[] {
+  return inspect(label, () => Array.isArray(value));
+}
+
+interface DataField {
+  key: string;
+  value: unknown;
+}
+
+function readDataRecord(value: unknown, label: string): readonly DataField[] {
+  return inspect(label, () => {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+      fail(`${label} must be a plain object`);
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      fail(`${label} must have a plain data prototype`);
+    }
+    const ownKeys = Reflect.ownKeys(value);
+    const keys: string[] = [];
+    for (let index = 0; index < ownKeys.length; index += 1) {
+      const key = ownKeys[index];
+      if (typeof key !== "string") fail(`${label} contains a non-string field`);
+      keys.push(key);
+    }
+    for (let index = 1; index < keys.length; index += 1) {
+      const key = keys[index]!;
+      let position = index - 1;
+      while (position >= 0 && keys[position]! > key) {
+        keys[position + 1] = keys[position]!;
+        position -= 1;
+      }
+      keys[position + 1] = key;
+    }
+    const fields: DataField[] = [];
+    for (let fieldIndex = 0; fieldIndex < keys.length; fieldIndex += 1) {
+      const key = keys[fieldIndex]!;
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) {
+        fail(`${label} field at index ${fieldIndex} must be enumerable own data`);
+      }
+      fields.push({ key, value: descriptor.value });
+    }
+    return fields;
+  });
+}
+
+function valuesByKey(fields: readonly DataField[]): ReadonlyMap<string, unknown> {
+  const values = new Map<string, unknown>();
+  for (const { key, value } of fields) values.set(key, value);
+  return values;
+}
+
+function readDataArray(value: unknown, label: string): readonly unknown[] {
+  return inspect(label, () => {
+    if (!Array.isArray(value)) fail(`${label} must be an array`);
+    if (Object.getPrototypeOf(value) !== Array.prototype) fail(`${label} must use the intrinsic array prototype`);
+
+    const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+    const length = lengthDescriptor && "value" in lengthDescriptor ? lengthDescriptor.value : -1;
+    if (!Number.isSafeInteger(length) || length < 0) fail(`${label} has an invalid length`);
+
+    const ownKeys = Reflect.ownKeys(value);
+    for (let fieldIndex = 0; fieldIndex < ownKeys.length; fieldIndex += 1) {
+      const key = ownKeys[fieldIndex];
+      if (key === "length") continue;
+      if (typeof key !== "string" || !/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= length) {
+        fail(`${label} contains a rejected array field`);
+      }
+    }
+
+    const items: unknown[] = [];
+    for (let index = 0; index < length; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+      if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) {
+        fail(`${label} item at index ${index} must be dense enumerable own data`);
+      }
+      items.push(descriptor.value);
+    }
+    return items;
+  });
+}
+
+function isHyphenatedNameLike(value: string): boolean {
+  const words = value.split("-");
+  if (words.length < 2) return false;
+  for (let index = 0; index < words.length; index += 1) {
+    if (!IDENTIFIER_WORD.test(words[index]!)) return false;
+  }
+  const candidateWords = TECHNICAL_IDENTIFIER_PREFIXES.has(words[0]!.toLowerCase()) ? words.slice(1) : words;
+  return candidateWords.length >= 2;
+}
+
+function sanitizeString(value: string): string {
+  return AUTH_VALUE.test(value)
+    || EMAIL_VALUE.test(value)
+    || PHONE_VALUE.test(value)
+    || SSN_VALUE.test(value)
+    || PAYMENT_NUMBER_VALUE.test(value)
+    || GOVERNMENT_ID_VALUE.test(value)
+    || ADDRESS_VALUE.test(value)
+    || PERSON_NAME_VALUE.test(value)
+    || HYPHENATED_ADDRESS_VALUE.test(value)
+    || isHyphenatedNameLike(value)
+    || LIVE_URL_VALUE.test(value)
+    || CODE_VALUE.test(value)
+    || CREDENTIAL_VALUE.test(value)
+    ? FAKE_REDACTION_MARKER
+    : value;
+}
+
+function sanitizeIdentifier(value: string): string {
+  const sanitized = sanitizeString(value);
+  return sanitized === value && SAFE_IDENTIFIER.test(value) ? value : FAKE_REDACTION_MARKER;
+}
+
+function sanitizeJson(value: unknown, path = "payload", seen = new WeakSet<object>()): JsonValue {
+  if (value === null || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) fail(`${path} must contain finite JSON numbers`);
+    return Math.abs(value) <= MAX_SAFE_FIXTURE_NUMBER ? value : FAKE_REDACTION_MARKER;
+  }
+  if (typeof value === "string") return sanitizeString(value);
+  if (typeof value !== "object") fail(`${path} must be JSON-compatible`);
+  if (seen.has(value)) fail(`${path} must not be cyclic`);
+  seen.add(value);
+
+  if (isArray(value, path)) {
+    const entries = readDataArray(value, path);
+    const result: JsonValue[] = [];
+    for (let index = 0; index < entries.length; index += 1) {
+      result.push(sanitizeJson(entries[index], `${path}[${index}]`, seen));
+    }
+    seen.delete(value);
+    return result;
+  }
+
+  const fields = readDataRecord(value, path);
+  const result: Record<string, JsonValue> = {};
+  for (let fieldIndex = 0; fieldIndex < fields.length; fieldIndex += 1) {
+    const { key, value: entry } = fields[fieldIndex]!;
+    const safeKey = UNSAFE_KEY.test(key) || !SAFE_IDENTIFIER.test(key) ? FAKE_REDACTION_MARKER : key;
+    result[safeKey] = safeKey === FAKE_REDACTION_MARKER
+      ? FAKE_REDACTION_MARKER
+      : sanitizeJson(entry, `${path}.$field[${fieldIndex}]`, seen);
+  }
+  seen.delete(value);
+  return result;
+}
+
+function copyJsonData(value: unknown, path: string, seen = new WeakSet<object>()): JsonValue {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) fail(`${path} must contain finite JSON numbers`);
+    return value;
+  }
+  if (typeof value !== "object") fail(`${path} must be JSON-compatible`);
+  if (seen.has(value)) fail(`${path} must not be cyclic`);
+  seen.add(value);
+
+  if (isArray(value, path)) {
+    const entries = readDataArray(value, path);
+    const result: JsonValue[] = [];
+    for (let index = 0; index < entries.length; index += 1) {
+      result.push(copyJsonData(entries[index], `${path}[${index}]`, seen));
+    }
+    seen.delete(value);
+    return result;
+  }
+
+  const fields = readDataRecord(value, path);
+  const result: Record<string, JsonValue> = {};
+  for (let fieldIndex = 0; fieldIndex < fields.length; fieldIndex += 1) {
+    const { key, value: entry } = fields[fieldIndex]!;
+    result[key] = copyJsonData(entry, `${path}.$field[${fieldIndex}]`, seen);
+  }
+  seen.delete(value);
+  return result;
+}
+
+function sanitizeHeaders(headers: Readonly<Record<string, string>> | undefined): Readonly<Record<string, string>> {
+  if (headers === undefined) return Object.freeze({});
+  const fields = readDataRecord(headers, "headers");
+  const sanitized: Record<string, string> = {};
+  for (let index = 0; index < fields.length; index += 1) {
+    const { key, value } = fields[index]!;
+    const name = key.toLowerCase();
+    if (typeof value !== "string") fail(`header at index ${index} must be a string`);
+    const safeName = UNSAFE_KEY.test(name) || !SAFE_HEADERS.has(name) ? FAKE_REDACTION_MARKER : name;
+    sanitized[safeName] = safeName === FAKE_REDACTION_MARKER
+      ? FAKE_REDACTION_MARKER
+      : sanitizeString(value);
+  }
+  return Object.freeze(sanitized);
+}
+
+function parseOutcome(outcome: unknown, index: number): FakeDestinationOutcome {
+  const fields = readDataRecord(outcome, `outcomes[${index}]`);
+  for (let fieldIndex = 0; fieldIndex < fields.length; fieldIndex += 1) {
+    const { key } = fields[fieldIndex]!;
+    if (key !== "kind" && key !== "status" && key !== "retryAfterMs") {
+      fail(`outcomes[${index}] field at index ${fieldIndex} is unsupported`);
+    }
+  }
+  const values = valuesByKey(fields);
+  const kind = values.get("kind");
+  const status = values.get("status");
+  const success = new Set([200, 201, 202, 204]);
+  const retryable = new Set([408, 425, 429, 500, 502, 503, 504]);
+  const terminal = new Set([400, 401, 403, 404, 409, 410, 422]);
+  const statusAllowed =
+    (kind === "success" && success.has(status as number)) ||
+    (kind === "retryable-failure" && retryable.has(status as number)) ||
+    (kind === "terminal-failure" && terminal.has(status as number));
+  if (!statusAllowed) fail(`outcomes[${index}] has an invalid kind/status pairing`);
+  if (values.has("retryAfterMs")) {
+    const retryAfterMs = values.get("retryAfterMs");
+    if (
+      kind !== "retryable-failure"
+      || !Number.isSafeInteger(retryAfterMs)
+      || (retryAfterMs as number) < 0
+      || (retryAfterMs as number) > MAX_RETRY_AFTER_MS
+    ) {
+      fail(`outcomes[${index}].retryAfterMs must be an integer from 0 through 86400000 on a retryable failure`);
+    }
+    return { kind, status: status as 408 | 425 | 429 | 500 | 502 | 503 | 504, retryAfterMs: retryAfterMs as number };
+  }
+  return { kind, status } as FakeDestinationOutcome;
+}
+
+function clone<T>(value: T): T {
+  return structuredClone(value);
+}
+
+function canonical(value: unknown): string {
+  return JSON.stringify(value);
+}
+
+/**
+ * Build an isolated deterministic destination. The outcome plan is finite:
+ * exhausting it is an assertion failure, so a conformance test cannot hide an
+ * unexpected delivery or retry.
+ */
+export function createFakeDestination(config: { outcomes: readonly FakeDestinationOutcome[] }): FakeDestination {
+  const configFields = readDataRecord(config, "config");
+  for (let fieldIndex = 0; fieldIndex < configFields.length; fieldIndex += 1) {
+    const { key } = configFields[fieldIndex]!;
+    if (!ALLOWED_CONFIG_KEYS.has(key)) {
+      fail(`config field at index ${fieldIndex} is unsupported`);
+    }
+  }
+  const configValues = valuesByKey(configFields);
+  if (!configValues.has("outcomes")) {
+    fail("outcomes must contain at least one planned result");
+  }
+  const outcomeInputs = readDataArray(configValues.get("outcomes"), "outcomes");
+  if (outcomeInputs.length === 0) fail("outcomes must contain at least one planned result");
+  const outcomes: FakeDestinationOutcome[] = [];
+  for (let index = 0; index < outcomeInputs.length; index += 1) {
+    outcomes.push(parseOutcome(outcomeInputs[index], index));
+  }
+  const captured: FakeDeliveryReceipt[] = [];
+
+  return Object.freeze({
+    id: FAKE_DESTINATION_ID,
+    async deliver(attempt: FakeDeliveryAttempt): Promise<FakeDeliveryReceipt> {
+      const attemptFields = readDataRecord(attempt, "attempt");
+      for (let fieldIndex = 0; fieldIndex < attemptFields.length; fieldIndex += 1) {
+        const { key } = attemptFields[fieldIndex]!;
+        if (!ALLOWED_ATTEMPT_KEYS.has(key)) fail(`attempt field at index ${fieldIndex} is unsupported`);
+      }
+      const attemptValues = valuesByKey(attemptFields);
+      const deliveryId = attemptValues.get("deliveryId");
+      const eventType = attemptValues.get("eventType");
+      if (typeof deliveryId !== "string" || deliveryId.length === 0) fail("deliveryId is required");
+      if (typeof eventType !== "string" || eventType.length === 0) fail("eventType is required");
+
+      const outcome = outcomes[captured.length];
+      if (!outcome) {
+        throw new Error(`Fake destination outcome plan exhausted after ${captured.length} attempt(s)`);
+      }
+      const attemptNumber = captured.length + 1;
+      const receipt: FakeDeliveryReceipt = {
+        receiptId: `fake-receipt-${String(attemptNumber).padStart(4, "0")}`,
+        attemptNumber,
+        destination: FAKE_DESTINATION_ID,
+        deliveryId: sanitizeIdentifier(deliveryId),
+        eventType: sanitizeIdentifier(eventType),
+        request: {
+          payload: sanitizeJson(attemptValues.get("payload")),
+          headers: sanitizeHeaders(attemptValues.get("headers") as Readonly<Record<string, string>> | undefined),
+        },
+        outcome: clone(outcome),
+      };
+      captured.push(receipt);
+      return clone(receipt);
+    },
+    receipts(): readonly FakeDeliveryReceipt[] {
+      return clone(captured);
+    },
+    assertReceipts(expected: readonly FakeDeliveryReceipt[]): void {
+      const expectedSnapshot = copyJsonData(expected, "expected receipts");
+      if (!Array.isArray(expectedSnapshot)) fail("expected receipts must be an array");
+      const actualJson = canonical(copyJsonData(captured, "captured receipts"));
+      const expectedJson = canonical(expectedSnapshot);
+      if (actualJson !== expectedJson) {
+        throw new Error(
+          `Fake destination receipts did not match (${expectedSnapshot.length} expected, ${captured.length} captured)`,
+        );
+      }
+    },
+  });
+}

package/packages/public-runtime/tests/fixtures/publication-spaces/internal.json

@@ -0,0 +1,32 @@
+{
+  "version": 1,
+  "id": "knowledge",
+  "tenant": "fixture.example",
+  "source": {
+    "forge": "fixture",
+    "repo": "fixture-private-publications",
+    "defaultBranch": "main"
+  },
+  "routes": {
+    "canonicalMount": "/knowledge"
+  },
+  "visibility": "internal",
+  "authorization": {
+    "policy": "capability",
+    "capability": "internal-content-reader"
+  },
+  "discovery": {
+    "sitemap": false,
+    "feeds": false,
+    "publicSearch": false,
+    "llms": false
+  },
+  "assets": {
+    "namespace": "knowledge",
+    "access": "authorized"
+  },
+  "renderer": {
+    "contractVersion": "storefront-v1",
+    "themeContractVersion": "theme-v1"
+  }
+}

package/packages/public-runtime/tests/fixtures/publication-spaces/mounted-public.json

@@ -0,0 +1,38 @@
+{
+  "version": 1,
+  "id": "articles",
+  "tenant": "fixture.example",
+  "source": {
+    "forge": "fixture",
+    "repo": "fixture-publications",
+    "defaultBranch": "main"
+  },
+  "routes": {
+    "canonicalMount": "/blog",
+    "aliases": [
+      {
+        "from": "/the-build",
+        "behavior": "redirect-308",
+        "to": "/blog"
+      }
+    ]
+  },
+  "visibility": "public",
+  "authorization": {
+    "policy": "public"
+  },
+  "discovery": {
+    "sitemap": true,
+    "feeds": true,
+    "publicSearch": true,
+    "llms": true
+  },
+  "assets": {
+    "namespace": "articles",
+    "access": "public"
+  },
+  "renderer": {
+    "contractVersion": "storefront-v1",
+    "themeContractVersion": "theme-v1"
+  }
+}

package/packages/public-runtime/tests/fixtures/publication-spaces/normalized-mounts.json

@@ -0,0 +1,39 @@
+[
+  {
+    "version": 1,
+    "tenant": "fixture.example",
+    "spaceId": "knowledge",
+    "kind": "canonical",
+    "mount": "/knowledge",
+    "canonicalMount": "/knowledge",
+    "behavior": "render"
+  },
+  {
+    "version": 1,
+    "tenant": "fixture.example",
+    "spaceId": "articles",
+    "kind": "alias",
+    "mount": "/the-build",
+    "canonicalMount": "/blog",
+    "behavior": "redirect-308",
+    "redirectTo": "/blog"
+  },
+  {
+    "version": 1,
+    "tenant": "fixture.example",
+    "spaceId": "articles",
+    "kind": "canonical",
+    "mount": "/blog",
+    "canonicalMount": "/blog",
+    "behavior": "render"
+  },
+  {
+    "version": 1,
+    "tenant": "fixture.example",
+    "spaceId": "root",
+    "kind": "canonical",
+    "mount": "/",
+    "canonicalMount": "/",
+    "behavior": "render"
+  }
+]

package/packages/public-runtime/tests/fixtures/publication-spaces/ref.json

@@ -0,0 +1,5 @@
+{
+  "version": 1,
+  "tenant": "fixture.example",
+  "spaceId": "articles"
+}

package/packages/public-runtime/tests/fixtures/publication-spaces/root-public.json

@@ -0,0 +1,31 @@
+{
+  "version": 1,
+  "id": "root",
+  "tenant": "fixture.example",
+  "source": {
+    "forge": "fixture",
+    "repo": "fixture.example",
+    "defaultBranch": "main"
+  },
+  "routes": {
+    "canonicalMount": "/"
+  },
+  "visibility": "public",
+  "authorization": {
+    "policy": "public"
+  },
+  "discovery": {
+    "sitemap": true,
+    "feeds": true,
+    "publicSearch": true,
+    "llms": true
+  },
+  "assets": {
+    "namespace": "root",
+    "access": "public"
+  },
+  "renderer": {
+    "contractVersion": "storefront-v1",
+    "themeContractVersion": "theme-v1"
+  }
+}

package/packages/public-runtime/tests/fixtures/publication-versions/articles-v1.json

@@ -0,0 +1,20 @@
+{
+  "schemaVersion": 1,
+  "versionId": "pv_articles-version-0001",
+  "tenant": "fixture.example",
+  "spaceId": "articles",
+  "source": {
+    "forge": "fixture",
+    "repo": "fixture-publications",
+    "commitSha": "3333333333333333333333333333333333333333"
+  },
+  "renderer": {
+    "contractVersion": "storefront-v1",
+    "themeContractVersion": "theme-v1"
+  },
+  "artifactDigest": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+  "createdAt": "2026-09-01T12:02:00.000Z",
+  "metadata": {
+    "buildId": "build-articles-0001"
+  }
+}

package/packages/public-runtime/tests/fixtures/publication-versions/articles-v2.json

@@ -0,0 +1,20 @@
+{
+  "schemaVersion": 1,
+  "versionId": "pv_articles-version-0002",
+  "tenant": "fixture.example",
+  "spaceId": "articles",
+  "source": {
+    "forge": "fixture",
+    "repo": "fixture-publications",
+    "commitSha": "4444444444444444444444444444444444444444"
+  },
+  "renderer": {
+    "contractVersion": "storefront-v1",
+    "themeContractVersion": "theme-v1"
+  },
+  "artifactDigest": "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
+  "createdAt": "2026-09-01T12:03:00.000Z",
+  "metadata": {
+    "buildId": "build-articles-0002"
+  }
+}

package/packages/public-runtime/tests/fixtures/publication-versions/internal-v1.json

@@ -0,0 +1,20 @@
+{
+  "schemaVersion": 1,
+  "versionId": "pv_knowledge-version-0001",
+  "tenant": "fixture.example",
+  "spaceId": "knowledge",
+  "source": {
+    "forge": "fixture",
+    "repo": "fixture-private-publications",
+    "commitSha": "5555555555555555555555555555555555555555"
+  },
+  "renderer": {
+    "contractVersion": "storefront-v1",
+    "themeContractVersion": "theme-v1"
+  },
+  "artifactDigest": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+  "createdAt": "2026-09-01T12:04:00.000Z",
+  "metadata": {
+    "buildId": "build-knowledge-0001"
+  }
+}

package/packages/public-runtime/tests/fixtures/publication-versions/live-pointer.json

@@ -0,0 +1,11 @@
+{
+  "schemaVersion": 1,
+  "tenant": "fixture.example",
+  "spaceId": "articles",
+  "channel": "live",
+  "revision": 1,
+  "versionId": "pv_articles-version-0001",
+  "sourceSha": "3333333333333333333333333333333333333333",
+  "artifactDigest": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+  "updatedAt": "2026-09-01T12:05:00.000Z"
+}

package/packages/public-runtime/tests/fixtures/publication-versions/live-transition-request.json

@@ -0,0 +1,14 @@
+{
+  "schemaVersion": 1,
+  "transitionId": "activate-articles-0001",
+  "operation": "activate",
+  "tenant": "fixture.example",
+  "spaceId": "articles",
+  "channel": "live",
+  "targetVersionId": "pv_articles-version-0001",
+  "expectedSourceSha": "3333333333333333333333333333333333333333",
+  "expectedArtifactDigest": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+  "expectedRevision": 0,
+  "principal": "publisher.fixture",
+  "occurredAt": "2026-09-01T12:05:00.000Z"
+}

package/packages/public-runtime/tests/fixtures/publication-versions/live-transition.json

@@ -0,0 +1,17 @@
+{
+  "schemaVersion": 1,
+  "transitionId": "activate-articles-0001",
+  "operation": "activate",
+  "tenant": "fixture.example",
+  "spaceId": "articles",
+  "channel": "live",
+  "previous": null,
+  "next": {
+    "revision": 1,
+    "versionId": "pv_articles-version-0001",
+    "sourceSha": "3333333333333333333333333333333333333333",
+    "artifactDigest": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
+  },
+  "principal": "publisher.fixture",
+  "occurredAt": "2026-09-01T12:05:00.000Z"
+}