@aura3d/editor-runtime 1.4.0 → 1.4.1

package/src/LocalizationAccessibilityFixtures.ts

@@ -1,368 +0,0 @@
-export type EditorLocaleDirection = "ltr" | "rtl";
-export type EditorPluralCategory = "zero" | "one" | "two" | "few" | "many" | "other";
-export type EditorAccessibilityRole = "button" | "navigation" | "slider" | "textbox" | "status" | "dialog";
-
-export interface EditorLocaleDescriptor {
-  readonly code: string;
-  readonly displayName: string;
-  readonly direction: EditorLocaleDirection;
-  readonly currencySymbol: string;
-  readonly decimalSeparator: string;
-  readonly thousandsSeparator: string;
-  readonly currencyPosition: "before" | "after";
-}
-
-export interface EditorLocalizedStringSample {
-  readonly locale: string;
-  readonly direction: EditorLocaleDirection;
-  readonly title: string;
-  readonly assetCount: string;
-  readonly fallbackTitle: string;
-  readonly missingKey: string;
-  readonly formattedNumber: string;
-  readonly formattedCurrency: string;
-  readonly pluralCategory: EditorPluralCategory;
-}
-
-export interface EditorAccessibilityElementSample {
-  readonly id: string;
-  readonly role: EditorAccessibilityRole;
-  readonly label: string;
-  readonly tabIndex: number;
-  readonly focusable: boolean;
-  readonly disabled?: boolean;
-  readonly ariaLive?: "polite" | "assertive";
-  readonly contrastRatio: number;
-  readonly contrastPassesAA: boolean;
-}
-
-export interface EditorLocalizationAccessibilityFixture {
-  readonly source: "origin-master-localization-ui-accessibility-adapted";
-  readonly sourceFiles: readonly string[];
-  readonly localeCount: number;
-  readonly rtlLocaleCount: number;
-  readonly tableKeyCount: number;
-  readonly jsonLoaderValidated: boolean;
-  readonly csvLoaderValidated: boolean;
-  readonly hotSwapLocale: {
-    readonly from: string;
-    readonly to: string;
-    readonly directionChanged: boolean;
-    readonly listenerNotifications: readonly string[];
-  };
-  readonly samples: readonly EditorLocalizedStringSample[];
-  readonly missingKeys: readonly string[];
-  readonly accessibility: {
-    readonly elementCount: number;
-    readonly labelledControls: number;
-    readonly focusOrder: readonly string[];
-    readonly focusWalk: readonly string[];
-    readonly liveRegionAnnouncements: readonly string[];
-    readonly highContrastMode: boolean;
-    readonly minContrastRatio: number;
-    readonly aaContrastPasses: boolean;
-  };
-  readonly blockedClaims: readonly string[];
-  readonly claimBoundary: string;
-  readonly hash: string;
-}
-
-type StringTable = Record<string, string>;
-
-const sourceFiles = [
-  "origin/master:src/localization/LocalizationManager.ts",
-  "origin/master:src/localization/StringTable.ts",
-  "origin/master:src/localization/Locale.ts",
-  "origin/master:src/localization/Pluralization.ts",
-  "origin/master:src/localization/loaders/JSONLocaleLoader.ts",
-  "origin/master:src/localization/loaders/CSVLocaleLoader.ts",
-  "origin/master:src/ui/UIAccessibility.ts"
-] as const;
-
-const blockedClaims = [
-  "full localization pipeline",
-  "ICU MessageFormat parity",
-  "bidirectional text shaping parity",
-  "screen-reader certification",
-  "WCAG conformance certification",
-  "Unity UI Toolkit parity",
-  "Unreal UMG parity"
-] as const;
-
-const locales: readonly EditorLocaleDescriptor[] = [
-  {
-    code: "en-US",
-    displayName: "English (United States)",
-    direction: "ltr",
-    currencySymbol: "$",
-    decimalSeparator: ".",
-    thousandsSeparator: ",",
-    currencyPosition: "before"
-  },
-  {
-    code: "es-ES",
-    displayName: "Spanish (Spain)",
-    direction: "ltr",
-    currencySymbol: "EUR",
-    decimalSeparator: ",",
-    thousandsSeparator: ".",
-    currencyPosition: "after"
-  },
-  {
-    code: "ar-SA",
-    displayName: "Arabic (Saudi Arabia)",
-    direction: "rtl",
-    currencySymbol: "SAR",
-    decimalSeparator: ".",
-    thousandsSeparator: ",",
-    currencyPosition: "after"
-  }
-] as const;
-
-const stringTables: Record<string, StringTable> = {
-  "en-US": {
-    "editor.title": "Aura3D Editor",
-    "assets.count.one": "{count} imported asset",
-    "assets.count.other": "{count} imported assets",
-    "status.saved": "Saved",
-    "panel.inspector": "Inspector"
-  },
-  "es-ES": {
-    "editor.title": "Editor Aura3D",
-    "assets.count.one": "{count} recurso importado",
-    "assets.count.other": "{count} recursos importados",
-    "status.saved": "Guardado"
-  },
-  "ar-SA": {
-    "editor.title": "Aura3D RTL Editor",
-    "assets.count.zero": "no imported assets",
-    "assets.count.one": "{count} imported asset",
-    "assets.count.two": "{count} imported assets",
-    "assets.count.few": "{count} imported assets",
-    "assets.count.many": "{count} imported assets",
-    "assets.count.other": "{count} imported assets",
-    "status.saved": "Saved RTL"
-  }
-};
-
-const accessibilityElements: readonly EditorAccessibilityElementSample[] = [
-  createAccessibilityElement("command-menu", "navigation", "Command menu", 1, "#f7fafc", "#101820"),
-  createAccessibilityElement("viewport", "status", "Editor WebGL viewport", 2, "#f5f7fb", "#07111c", "polite"),
-  createAccessibilityElement("inspector-name", "textbox", "Selected node name", 3, "#111827", "#f9fafb"),
-  createAccessibilityElement("timeline-scrub", "slider", "Timeline scrub time", 4, "#0f172a", "#e0f2fe"),
-  createAccessibilityElement("export-project", "button", "Export Project", 5, "#ffffff", "#1d4ed8")
-];
-
-export function sampleLocalizationAccessibilityFixture(options: {
-  readonly assetCount?: number;
-  readonly hotSwapFrom?: string;
-  readonly hotSwapTo?: string;
-} = {}): EditorLocalizationAccessibilityFixture {
-  const assetCount = Math.max(0, Math.floor(options.assetCount ?? 2));
-  const hotSwapFrom = options.hotSwapFrom ?? "en-US";
-  const hotSwapTo = options.hotSwapTo ?? "ar-SA";
-  const fromLocale = requireLocale(hotSwapFrom);
-  const toLocale = requireLocale(hotSwapTo);
-  const listenerNotifications = [fromLocale.code, toLocale.code];
-  const samples = locales.map((locale) => sampleLocale(locale, assetCount));
-  const missingKeys = findMissingKeys(stringTables["en-US"] ?? {}, stringTables["es-ES"] ?? {});
-  const focusOrder = accessibilityElements
-    .filter((element) => element.focusable && !element.disabled)
-    .sort((left, right) => left.tabIndex - right.tabIndex)
-    .map((element) => element.id);
-  const focusWalk = [focusOrder[0], focusOrder[1], focusOrder[2], focusOrder[1]].filter((id): id is string => Boolean(id));
-  const minContrastRatio = Math.min(...accessibilityElements.map((element) => element.contrastRatio));
-  const fixtureWithoutHash = {
-    source: "origin-master-localization-ui-accessibility-adapted" as const,
-    sourceFiles,
-    localeCount: locales.length,
-    rtlLocaleCount: locales.filter((locale) => locale.direction === "rtl").length,
-    tableKeyCount: Object.values(stringTables).reduce((sum, table) => sum + Object.keys(table).length, 0),
-    jsonLoaderValidated: validateJsonTableShape(stringTables),
-    csvLoaderValidated: validateCsvTableShape(toCsv(stringTables)),
-    hotSwapLocale: {
-      from: fromLocale.code,
-      to: toLocale.code,
-      directionChanged: fromLocale.direction !== toLocale.direction,
-      listenerNotifications
-    },
-    samples,
-    missingKeys,
-    accessibility: {
-      elementCount: accessibilityElements.length,
-      labelledControls: accessibilityElements.filter((element) => element.label.trim().length > 0).length,
-      focusOrder,
-      focusWalk,
-      liveRegionAnnouncements: ["Focused: Command menu", "Focused: Editor WebGL viewport", "Saved"],
-      highContrastMode: true,
-      minContrastRatio,
-      aaContrastPasses: accessibilityElements.every((element) => element.contrastPassesAA)
-    },
-    blockedClaims,
-    claimBoundary: "This fixture ports bounded old localization and UI accessibility concepts into deterministic editor-runtime evidence. It does not certify WCAG compliance, native assistive technology behavior, ICU parity, or Unity/Unreal UI parity."
-  };
-  return {
-    ...fixtureWithoutHash,
-    hash: stableHash(JSON.stringify(fixtureWithoutHash))
-  };
-}
-
-function sampleLocale(locale: EditorLocaleDescriptor, assetCount: number): EditorLocalizedStringSample {
-  const pluralCategory = cardinalPluralCategory(locale.code, assetCount);
-  const table = stringTables[locale.code] ?? {};
-  const fallback = stringTables["en-US"] ?? {};
-  return {
-    locale: locale.code,
-    direction: locale.direction,
-    title: lookup(table, fallback, "editor.title", {}),
-    assetCount: lookup(table, fallback, `assets.count.${pluralCategory}`, { count: assetCount }),
-    fallbackTitle: lookup(table, fallback, "panel.inspector", {}),
-    missingKey: lookup(table, fallback, "missing.key", {}),
-    formattedNumber: formatNumber(locale, 1234.5, 2),
-    formattedCurrency: formatCurrency(locale, 1234.5),
-    pluralCategory
-  };
-}
-
-function lookup(table: StringTable, fallback: StringTable, key: string, params: Record<string, number | string>): string {
-  const template = table[key] ?? fallback[key];
-  if (!template) return `[${key}]`;
-  return template.replace(/\{([^}]+)\}/g, (match, name) => String(params[name] ?? match));
-}
-
-function cardinalPluralCategory(localeCode: string, count: number): EditorPluralCategory {
-  const language = localeCode.split("-")[0] ?? localeCode;
-  if (language === "ar") {
-    if (count === 0) return "zero";
-    if (count === 1) return "one";
-    if (count === 2) return "two";
-    if (count % 100 >= 3 && count % 100 <= 10) return "few";
-    if (count % 100 >= 11 && count % 100 <= 99) return "many";
-    return "other";
-  }
-  return count === 1 ? "one" : "other";
-}
-
-function formatNumber(locale: EditorLocaleDescriptor, value: number, decimals: number): string {
-  const fixed = value.toFixed(decimals);
-  const [integer = "0", decimal = ""] = fixed.split(".");
-  const grouped = integer.replace(/\B(?=(\d{3})+(?!\d))/g, locale.thousandsSeparator);
-  return decimal.length > 0 ? `${grouped}${locale.decimalSeparator}${decimal}` : grouped;
-}
-
-function formatCurrency(locale: EditorLocaleDescriptor, value: number): string {
-  const formatted = formatNumber(locale, value, 2);
-  return locale.currencyPosition === "before" ? `${locale.currencySymbol}${formatted}` : `${formatted} ${locale.currencySymbol}`;
-}
-
-function findMissingKeys(reference: StringTable, target: StringTable): readonly string[] {
-  return Object.keys(reference).filter((key) => target[key] === undefined).sort();
-}
-
-function requireLocale(code: string): EditorLocaleDescriptor {
-  const locale = locales.find((candidate) => candidate.code === code);
-  if (!locale) throw new Error(`Unknown editor locale fixture: ${code}`);
-  return locale;
-}
-
-function validateJsonTableShape(tables: Record<string, StringTable>): boolean {
-  return Object.values(tables).every((table) => Object.values(table).every((value) => typeof value === "string" && value.length > 0));
-}
-
-function validateCsvTableShape(csv: string): boolean {
-  const rows = csv.split("\n").filter((line) => line.trim().length > 0);
-  if (rows.length < 2) return false;
-  const expectedColumns = parseCsvLine(rows[0] ?? "").length;
-  return expectedColumns >= 2 && rows.slice(1).every((line) => parseCsvLine(line).length === expectedColumns);
-}
-
-function toCsv(tables: Record<string, StringTable>): string {
-  const localeCodes = Object.keys(tables).sort();
-  const keys = [...new Set(localeCodes.flatMap((locale) => Object.keys(tables[locale] ?? {})))].sort();
-  return [
-    ["Key", ...localeCodes].join(","),
-    ...keys.map((key) => [key, ...localeCodes.map((locale) => escapeCsv(tables[locale]?.[key] ?? ""))].join(","))
-  ].join("\n");
-}
-
-function parseCsvLine(line: string): readonly string[] {
-  const columns: string[] = [];
-  let current = "";
-  let quoted = false;
-  for (let index = 0; index < line.length; index += 1) {
-    const char = line[index];
-    const next = line[index + 1];
-    if (char === "\"") {
-      if (quoted && next === "\"") {
-        current += "\"";
-        index += 1;
-      } else {
-        quoted = !quoted;
-      }
-    } else if (char === "," && !quoted) {
-      columns.push(current);
-      current = "";
-    } else {
-      current += char;
-    }
-  }
-  columns.push(current);
-  return columns;
-}
-
-function escapeCsv(value: string): string {
-  return value.includes(",") || value.includes("\"") || value.includes("\n") ? `"${value.replace(/"/g, "\"\"")}"` : value;
-}
-
-function createAccessibilityElement(
-  id: string,
-  role: EditorAccessibilityRole,
-  label: string,
-  tabIndex: number,
-  foreground: string,
-  background: string,
-  ariaLive?: "polite" | "assertive"
-): EditorAccessibilityElementSample {
-  const contrastRatio = Number(contrast(foreground, background).toFixed(2));
-  return {
-    id,
-    role,
-    label,
-    tabIndex,
-    focusable: true,
-    ...(ariaLive ? { ariaLive } : {}),
-    contrastRatio,
-    contrastPassesAA: contrastRatio >= 4.5
-  };
-}
-
-function contrast(foreground: string, background: string): number {
-  const foregroundLum = luminance(hexToRgb(foreground));
-  const backgroundLum = luminance(hexToRgb(background));
-  const light = Math.max(foregroundLum, backgroundLum);
-  const dark = Math.min(foregroundLum, backgroundLum);
-  return (light + 0.05) / (dark + 0.05);
-}
-
-function hexToRgb(hex: string): readonly [number, number, number] {
-  const normalized = hex.replace("#", "");
-  return [
-    Number.parseInt(normalized.slice(0, 2), 16) / 255,
-    Number.parseInt(normalized.slice(2, 4), 16) / 255,
-    Number.parseInt(normalized.slice(4, 6), 16) / 255
-  ];
-}
-
-function luminance(rgb: readonly [number, number, number]): number {
-  const [r, g, b] = rgb.map((channel) => channel <= 0.03928 ? channel / 12.92 : ((channel + 0.055) / 1.055) ** 2.4);
-  return 0.2126 * (r ?? 0) + 0.7152 * (g ?? 0) + 0.0722 * (b ?? 0);
-}
-
-function stableHash(value: string): string {
-  let hash = 0x811c9dc5;
-  for (let index = 0; index < value.length; index += 1) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 0x01000193);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}

package/src/MaterialVariantWorkflow.ts

@@ -1,101 +0,0 @@
-export interface MaterialVariantState {
-  readonly assetId: string;
-  readonly variants: readonly string[];
-  readonly selected: string | null;
-}
-
-export interface MaterialVariantRenderOptions {
-  readonly materialVariant?: string;
-}
-
-export class MaterialVariantWorkflow {
-  private readonly states = new Map<string, MaterialVariantState>();
-
-  register(assetId: string, variants: readonly string[], selected: string | null = null): MaterialVariantState {
-    const normalizedAssetId = normalizeAssetId(assetId);
-    const normalizedVariants = normalizeVariants(variants);
-    const normalizedSelected = selected === null ? null : normalizeVariantName(selected);
-    if (normalizedSelected !== null && !normalizedVariants.includes(normalizedSelected)) {
-      throw new Error(`Material variant ${normalizedSelected} is not available for asset ${normalizedAssetId}.`);
-    }
-    const state = {
-      assetId: normalizedAssetId,
-      variants: normalizedVariants,
-      selected: normalizedSelected
-    };
-    this.states.set(normalizedAssetId, state);
-    return state;
-  }
-
-  unregister(assetId: string): void {
-    this.states.delete(normalizeAssetId(assetId));
-  }
-
-  select(assetId: string, variant: string | null): MaterialVariantState {
-    const normalizedAssetId = normalizeAssetId(assetId);
-    const state = this.states.get(normalizedAssetId);
-    if (!state) {
-      throw new Error(`Material variant asset ${normalizedAssetId} is not registered.`);
-    }
-    const selected = variant === null ? null : normalizeVariantName(variant);
-    if (selected !== null && !state.variants.includes(selected)) {
-      throw new Error(`Material variant ${selected} is not available for asset ${normalizedAssetId}.`);
-    }
-    const next = { ...state, selected };
-    this.states.set(normalizedAssetId, next);
-    return next;
-  }
-
-  state(assetId: string): MaterialVariantState {
-    const normalizedAssetId = normalizeAssetId(assetId);
-    const state = this.states.get(normalizedAssetId);
-    if (!state) {
-      throw new Error(`Material variant asset ${normalizedAssetId} is not registered.`);
-    }
-    return state;
-  }
-
-  snapshot(): readonly MaterialVariantState[] {
-    return [...this.states.values()].map((state) => ({
-      assetId: state.assetId,
-      variants: [...state.variants],
-      selected: state.selected
-    }));
-  }
-
-  renderOptions(assetId: string): MaterialVariantRenderOptions {
-    const selected = this.state(assetId).selected;
-    return selected === null ? {} : { materialVariant: selected };
-  }
-
-  clear(): void {
-    this.states.clear();
-  }
-}
-
-function normalizeAssetId(assetId: string): string {
-  const normalized = assetId.trim();
-  if (normalized.length === 0) {
-    throw new Error("Material variant asset id cannot be empty.");
-  }
-  return normalized;
-}
-
-function normalizeVariantName(variant: string): string {
-  const normalized = variant.trim();
-  if (normalized.length === 0) {
-    throw new Error("Material variant name cannot be empty.");
-  }
-  return normalized;
-}
-
-function normalizeVariants(variants: readonly string[]): readonly string[] {
-  if (variants.length === 0) {
-    throw new Error("Material variant list cannot be empty.");
-  }
-  const normalized = variants.map(normalizeVariantName);
-  if (new Set(normalized).size !== normalized.length) {
-    throw new Error("Material variant list cannot contain duplicate names.");
-  }
-  return normalized;
-}

package/src/MultiUserReviewWorkflow.ts

@@ -1,229 +0,0 @@
-export type ReviewParticipantRole = "owner" | "reviewer" | "animator" | "audio" | "viewer";
-export type ReviewDecisionStatus = "pending" | "approved" | "changes-requested";
-export type ReviewWorkflowStatus = "draft" | "needs-review" | "changes-requested" | "approved";
-
-export interface ReviewParticipant {
-  readonly id: string;
-  readonly name: string;
-  readonly role: ReviewParticipantRole;
-  readonly active?: boolean | undefined;
-}
-
-export interface ReviewThread {
-  readonly id: string;
-  readonly authorId: string;
-  readonly text: string;
-  readonly time?: number | undefined;
-  readonly frame?: number | undefined;
-  readonly assignedTo?: string | undefined;
-  readonly resolved: boolean;
-}
-
-export interface ReviewDecision {
-  readonly reviewerId: string;
-  readonly status: ReviewDecisionStatus;
-  readonly at: string;
-  readonly note?: string | undefined;
-}
-
-export interface MultiUserReviewWorkflowState {
-  readonly packageId: string;
-  readonly status?: ReviewWorkflowStatus | undefined;
-  readonly requiredReviewerCount?: number | undefined;
-  readonly participants: readonly ReviewParticipant[];
-  readonly threads: readonly ReviewThread[];
-  readonly decisions: readonly ReviewDecision[];
-}
-
-export interface MultiUserReviewWorkflowSnapshot {
-  readonly kind: "multi-user-review-workflow";
-  readonly packageId: string;
-  readonly status: ReviewWorkflowStatus;
-  readonly participantCount: number;
-  readonly activeParticipantCount: number;
-  readonly reviewerCount: number;
-  readonly requiredReviewerCount: number;
-  readonly approvedReviewerCount: number;
-  readonly changeRequestCount: number;
-  readonly threadCount: number;
-  readonly unresolvedThreadCount: number;
-  readonly assignedThreadCount: number;
-  readonly canPublish: boolean;
-  readonly participants: readonly ReviewParticipant[];
-  readonly threads: readonly ReviewThread[];
-  readonly decisions: readonly ReviewDecision[];
-  readonly evidence: {
-    readonly multiUserReview: boolean;
-    readonly assignmentWorkflow: boolean;
-    readonly reviewerQuorum: boolean;
-    readonly publishBlockedByOpenThreads: boolean;
-  };
-}
-
-export class MultiUserReviewWorkflow {
-  private packageId: string;
-  private status: ReviewWorkflowStatus;
-  private requiredReviewerCount: number;
-  private participants = new Map<string, ReviewParticipant>();
-  private threads = new Map<string, ReviewThread>();
-  private decisions = new Map<string, ReviewDecision>();
-
-  constructor(state: MultiUserReviewWorkflowState) {
-    this.packageId = nonEmpty(state.packageId, "Review package id");
-    this.status = state.status ?? "needs-review";
-    this.requiredReviewerCount = Math.max(1, Math.floor(state.requiredReviewerCount ?? 1));
-    for (const participant of state.participants) this.addParticipant(participant);
-    for (const thread of state.threads) this.addThread(thread);
-    for (const decision of state.decisions) this.recordDecision(decision);
-  }
-
-  addParticipant(participant: ReviewParticipant): MultiUserReviewWorkflowSnapshot {
-    const clean = sanitizeParticipant(participant);
-    this.participants.set(clean.id, clean);
-    return this.snapshot();
-  }
-
-  addThread(thread: ReviewThread): MultiUserReviewWorkflowSnapshot {
-    const clean = sanitizeThread(thread);
-    this.requireParticipant(clean.authorId);
-    if (clean.assignedTo) this.requireParticipant(clean.assignedTo);
-    this.threads.set(clean.id, clean);
-    if (!clean.resolved && this.status === "approved") this.status = "changes-requested";
-    return this.snapshot();
-  }
-
-  assignThread(threadId: string, participantId: string): MultiUserReviewWorkflowSnapshot {
-    this.requireParticipant(participantId);
-    const thread = this.requireThread(threadId);
-    this.threads.set(threadId, { ...thread, assignedTo: participantId });
-    return this.snapshot();
-  }
-
-  resolveThread(threadId: string): MultiUserReviewWorkflowSnapshot {
-    const thread = this.requireThread(threadId);
-    this.threads.set(threadId, { ...thread, resolved: true });
-    return this.snapshot();
-  }
-
-  recordDecision(decision: ReviewDecision): MultiUserReviewWorkflowSnapshot {
-    const clean = sanitizeDecision(decision);
-    const participant = this.requireParticipant(clean.reviewerId);
-    if (participant.role !== "reviewer" && participant.role !== "owner") {
-      throw new Error(`Review participant "${clean.reviewerId}" is not allowed to approve or request changes.`);
-    }
-    this.decisions.set(clean.reviewerId, clean);
-    if (clean.status === "changes-requested") this.status = "changes-requested";
-    else if (this.snapshot().canPublish) this.status = "approved";
-    return this.snapshot();
-  }
-
-  markNeedsReview(): MultiUserReviewWorkflowSnapshot {
-    this.status = "needs-review";
-    return this.snapshot();
-  }
-
-  serialize(): MultiUserReviewWorkflowState {
-    return {
-      packageId: this.packageId,
-      status: this.status,
-      requiredReviewerCount: this.requiredReviewerCount,
-      participants: [...this.participants.values()],
-      threads: [...this.threads.values()],
-      decisions: [...this.decisions.values()]
-    };
-  }
-
-  snapshot(): MultiUserReviewWorkflowSnapshot {
-    const participants = [...this.participants.values()];
-    const threads = [...this.threads.values()];
-    const decisions = [...this.decisions.values()];
-    const reviewerCount = participants.filter((participant) => participant.role === "owner" || participant.role === "reviewer").length;
-    const approvedReviewerCount = decisions.filter((decision) => decision.status === "approved").length;
-    const changeRequestCount = decisions.filter((decision) => decision.status === "changes-requested").length;
-    const unresolvedThreadCount = threads.filter((thread) => !thread.resolved).length;
-    const canPublish = approvedReviewerCount >= this.requiredReviewerCount && changeRequestCount === 0 && unresolvedThreadCount === 0;
-    const status: ReviewWorkflowStatus = canPublish ? "approved" : changeRequestCount > 0 ? "changes-requested" : this.status === "draft" ? "draft" : "needs-review";
-    return {
-      kind: "multi-user-review-workflow",
-      packageId: this.packageId,
-      status,
-      participantCount: participants.length,
-      activeParticipantCount: participants.filter((participant) => participant.active !== false).length,
-      reviewerCount,
-      requiredReviewerCount: this.requiredReviewerCount,
-      approvedReviewerCount,
-      changeRequestCount,
-      threadCount: threads.length,
-      unresolvedThreadCount,
-      assignedThreadCount: threads.filter((thread) => Boolean(thread.assignedTo)).length,
-      canPublish,
-      participants,
-      threads,
-      decisions,
-      evidence: {
-        multiUserReview: participants.length > 1,
-        assignmentWorkflow: threads.some((thread) => Boolean(thread.assignedTo)),
-        reviewerQuorum: approvedReviewerCount >= this.requiredReviewerCount,
-        publishBlockedByOpenThreads: unresolvedThreadCount > 0
-      }
-    };
-  }
-
-  private requireParticipant(id: string): ReviewParticipant {
-    const participant = this.participants.get(id);
-    if (!participant) throw new Error(`Unknown review participant: ${id}`);
-    return participant;
-  }
-
-  private requireThread(id: string): ReviewThread {
-    const thread = this.threads.get(id);
-    if (!thread) throw new Error(`Unknown review thread: ${id}`);
-    return thread;
-  }
-}
-
-export function createMultiUserReviewWorkflow(state: MultiUserReviewWorkflowState): MultiUserReviewWorkflow {
-  return new MultiUserReviewWorkflow(state);
-}
-
-function sanitizeParticipant(participant: ReviewParticipant): ReviewParticipant {
-  return {
-    id: nonEmpty(participant.id, "Review participant id"),
-    name: nonEmpty(participant.name, "Review participant name"),
-    role: participant.role,
-    active: participant.active
-  };
-}
-
-function sanitizeThread(thread: ReviewThread): ReviewThread {
-  if (thread.time !== undefined && (!Number.isFinite(thread.time) || thread.time < 0)) {
-    throw new Error("Review thread time must be a non-negative finite number.");
-  }
-  if (thread.frame !== undefined && (!Number.isInteger(thread.frame) || thread.frame < 0)) {
-    throw new Error("Review thread frame must be a non-negative integer.");
-  }
-  return {
-    id: nonEmpty(thread.id, "Review thread id"),
-    authorId: nonEmpty(thread.authorId, "Review thread author"),
-    text: nonEmpty(thread.text, "Review thread text"),
-    time: thread.time,
-    frame: thread.frame,
-    assignedTo: thread.assignedTo,
-    resolved: thread.resolved
-  };
-}
-
-function sanitizeDecision(decision: ReviewDecision): ReviewDecision {
-  return {
-    reviewerId: nonEmpty(decision.reviewerId, "Review decision reviewer"),
-    status: decision.status,
-    at: nonEmpty(decision.at, "Review decision timestamp"),
-    note: decision.note
-  };
-}
-
-function nonEmpty(value: string, label: string): string {
-  const trimmed = value.trim();
-  if (!trimmed) throw new Error(`${label} must be a non-empty string.`);
-  return trimmed;
-}