@beyondwork/docx-react-component 1.0.0

package/services/react-word-editor/lib/validator-client.test.mjs

@@ -0,0 +1,54 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  getValidatorConfigurationHint,
+  getValidatorConfiguredAuthToken,
+  getValidatorRequestHeaders,
+} from "./validator-client.ts";
+
+test("validator configuration hint documents the public-domain fallback", () => {
+  assert.equal(
+    getValidatorConfigurationHint(),
+    "Configure OPENXML_VALIDATOR_BASE_URL. Prefer the Railway private domain; if you must use a public validator domain, also set OPENXML_VALIDATOR_AUTH_TOKEN.",
+  );
+});
+
+test("validator auth token is read from the environment when present", (t) => {
+  const originalToken = process.env.OPENXML_VALIDATOR_AUTH_TOKEN;
+  t.after(() => {
+    if (originalToken === undefined) {
+      delete process.env.OPENXML_VALIDATOR_AUTH_TOKEN;
+      return;
+    }
+
+    process.env.OPENXML_VALIDATOR_AUTH_TOKEN = originalToken;
+  });
+
+  delete process.env.OPENXML_VALIDATOR_AUTH_TOKEN;
+  assert.equal(getValidatorConfiguredAuthToken(), undefined);
+
+  process.env.OPENXML_VALIDATOR_AUTH_TOKEN = " shared-secret ";
+  assert.equal(getValidatorConfiguredAuthToken(), "shared-secret");
+});
+
+test("validator request headers inject bearer auth only when configured", (t) => {
+  const originalToken = process.env.OPENXML_VALIDATOR_AUTH_TOKEN;
+  t.after(() => {
+    if (originalToken === undefined) {
+      delete process.env.OPENXML_VALIDATOR_AUTH_TOKEN;
+      return;
+    }
+
+    process.env.OPENXML_VALIDATOR_AUTH_TOKEN = originalToken;
+  });
+
+  delete process.env.OPENXML_VALIDATOR_AUTH_TOKEN;
+  const publicHeaders = getValidatorRequestHeaders({ accept: "application/json" });
+  assert.equal(publicHeaders.get("accept"), "application/json");
+  assert.equal(publicHeaders.get("authorization"), null);
+
+  process.env.OPENXML_VALIDATOR_AUTH_TOKEN = "token-123";
+  const authenticatedHeaders = getValidatorRequestHeaders();
+  assert.equal(authenticatedHeaders.get("authorization"), "Bearer token-123");
+});

package/services/react-word-editor/lib/validator-client.ts

@@ -0,0 +1,95 @@
+import { DOCX_MIME_TYPE, type HarnessValidationReport } from "./storage.ts";
+
+export type ValidatorHealthResponse = {
+  service?: string;
+  status?: string;
+  sdk?: string;
+  endpoints?: string[];
+  [key: string]: unknown;
+};
+
+export function getValidatorConfigurationHint(): string {
+  return "Configure OPENXML_VALIDATOR_BASE_URL. Prefer the Railway private domain; if you must use a public validator domain, also set OPENXML_VALIDATOR_AUTH_TOKEN.";
+}
+
+export function getValidatorConfiguredBaseUrl(): string | undefined {
+  const baseUrl = process.env.OPENXML_VALIDATOR_BASE_URL?.trim();
+  return baseUrl ? baseUrl : undefined;
+}
+
+export function getValidatorConfiguredAuthToken(): string | undefined {
+  const token = process.env.OPENXML_VALIDATOR_AUTH_TOKEN?.trim();
+  return token ? token : undefined;
+}
+
+export function getValidatorRequestHeaders(
+  init?: HeadersInit,
+): Headers {
+  const headers = new Headers(init);
+  const authToken = getValidatorConfiguredAuthToken();
+
+  if (authToken) {
+    headers.set("authorization", `Bearer ${authToken}`);
+  }
+
+  return headers;
+}
+
+function requireValidatorBaseUrl(): string {
+  const baseUrl = getValidatorConfiguredBaseUrl();
+
+  if (!baseUrl) {
+    throw new Error(
+      "OPENXML_VALIDATOR_BASE_URL is required for live validation. The browser must not call the validator directly.",
+    );
+  }
+
+  return baseUrl;
+}
+
+export async function getValidatorHealth(): Promise<ValidatorHealthResponse> {
+  const response = await fetch(`${requireValidatorBaseUrl()}/health`, {
+    cache: "no-store",
+    headers: getValidatorRequestHeaders({
+      accept: "application/json",
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Validator health request failed with ${response.status}.`);
+  }
+
+  return (await response.json()) as ValidatorHealthResponse;
+}
+
+export function hasValidatorConfiguration(): boolean {
+  return Boolean(getValidatorConfiguredBaseUrl());
+}
+
+export async function validateDocxWithService(input: {
+  bytes: Uint8Array;
+  fileName: string;
+}): Promise<HarnessValidationReport> {
+  const uploadBytes = new Uint8Array(input.bytes);
+  const formData = new FormData();
+  formData.set(
+    "file",
+    new File([uploadBytes], input.fileName, {
+      type: DOCX_MIME_TYPE,
+    }),
+  );
+
+  const response = await fetch(`${requireValidatorBaseUrl()}/validate`, {
+    method: "POST",
+    body: formData,
+    cache: "no-store",
+    headers: getValidatorRequestHeaders(),
+  });
+
+  if (!response.ok) {
+    const detail = await response.text();
+    throw new Error(`Validator request failed with ${response.status}: ${detail}`);
+  }
+
+  return (await response.json()) as HarnessValidationReport;
+}

package/services/react-word-editor/lib/workspace-navigation.ts

@@ -0,0 +1,79 @@
+export type WorkspaceRouteKind = "demo" | "editor";
+
+export type WorkspacePanel =
+  | "library"
+  | "dashboard"
+  | "certification"
+  | "wave10-review"
+  | "run"
+  | "bundle";
+
+export type WorkspaceNavigationInput = {
+  routeKind: WorkspaceRouteKind;
+  sessionId: string;
+  panel?: WorkspacePanel | null;
+  runId?: string;
+  targetType?: string;
+  targetId?: string;
+  saved?: string;
+};
+
+export function parseWorkspacePanel(value: string | undefined): WorkspacePanel | null {
+  if (
+    value === "library" ||
+    value === "dashboard" ||
+    value === "certification" ||
+    value === "wave10-review" ||
+    value === "run" ||
+    value === "bundle"
+  ) {
+    return value;
+  }
+
+  return null;
+}
+
+export function buildWorkspaceHref(input: WorkspaceNavigationInput): string {
+  const params = new URLSearchParams();
+
+  if (input.routeKind === "demo") {
+    params.set("sessionId", input.sessionId);
+  }
+
+  if (input.panel) {
+    params.set("panel", input.panel);
+  }
+
+  if (input.runId) {
+    params.set("runId", input.runId);
+  }
+
+  if (input.targetType) {
+    params.set("targetType", input.targetType);
+  }
+
+  if (input.targetId) {
+    params.set("targetId", input.targetId);
+  }
+
+  if (input.saved) {
+    params.set("saved", input.saved);
+  }
+
+  if (input.routeKind === "editor") {
+    const query = params.toString();
+    return query ? `/editor/${input.sessionId}?${query}` : `/editor/${input.sessionId}`;
+  }
+
+  return `/demo?${params.toString()}`;
+}
+
+export function buildWorkspaceHomeHref(
+  routeKind: WorkspaceRouteKind,
+  sessionId: string,
+): string {
+  return buildWorkspaceHref({
+    routeKind,
+    sessionId,
+  });
+}

package/services/react-word-editor/middleware.ts

@@ -0,0 +1,35 @@
+import { NextResponse, type NextRequest } from "next/server";
+
+import {
+  getHarnessPrivateModeHint,
+  isHarnessPrivateModeEnabled,
+  shouldBypassHarnessPrivateMode,
+} from "./lib/private-mode";
+
+export function middleware(request: NextRequest) {
+  if (isHarnessPrivateModeEnabled()) {
+    return NextResponse.next();
+  }
+
+  if (shouldBypassHarnessPrivateMode(request.nextUrl.pathname)) {
+    return NextResponse.next();
+  }
+
+  return NextResponse.json(
+    {
+      error: "private_mode_required",
+      detail: "The harness is disabled until private-only mode is enabled.",
+      hint: getHarnessPrivateModeHint(),
+    },
+    {
+      status: 503,
+      headers: {
+        "cache-control": "no-store",
+      },
+    },
+  );
+}
+
+export const config = {
+  matcher: ["/((?!.*\\..*).*)"],
+};

package/services/react-word-editor/next-env.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+import "./.next/types/routes.d.ts";
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/services/react-word-editor/next.config.mjs

@@ -0,0 +1,15 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  reactStrictMode: true,
+  distDir: process.env.NEXT_DIST_DIR || ".next",
+  typescript: {
+    // Pre-existing type mismatches in src/core/ and src/io/ are tracked separately.
+    // The prototype harness compiles cleanly — these errors are in the runtime source.
+    ignoreBuildErrors: true,
+  },
+  experimental: {
+    externalDir: true
+  }
+};
+
+export default nextConfig;

package/services/react-word-editor/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@docx-react-component/react-word-editor-harness",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start -p ${PORT:-3000}",
+    "pilot:wave-9": "node scripts/wave-9-live-usability-pilot.mjs",
+    "certify:wave-10": "pnpm exec tsx scripts/wave-10-certification.mjs",
+    "test": "node --experimental-strip-types --test lib/*.test.mjs"
+  },
+  "dependencies": {
+    "@radix-ui/react-popover": "^1.1.15",
+    "@radix-ui/react-scroll-area": "^1.2.10",
+    "@radix-ui/react-select": "^2.2.6",
+    "@radix-ui/react-separator": "^1.1.8",
+    "@radix-ui/react-tabs": "^1.1.13",
+    "@radix-ui/react-toggle": "^1.1.10",
+    "@radix-ui/react-toggle-group": "^1.1.11",
+    "@radix-ui/react-tooltip": "^1.2.8",
+    "@tailwindcss/postcss": "^4.2.2",
+    "lucide-react": "^1.7.0",
+    "next": "16.2.1",
+    "postcss": "^8.5.8",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "server-only": "^0.0.1",
+    "tailwindcss": "^4.2.2"
+  },
+  "devDependencies": {
+    "@types/node": "25.5.0",
+    "@types/react": "19.2.14",
+    "@types/react-dom": "19.2.3",
+    "typescript": "6.0.2"
+  }
+}

package/services/react-word-editor/postcss.config.mjs

@@ -0,0 +1,8 @@
+/** @type {import('postcss-load-config').Config} */
+const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;

package/services/react-word-editor/railway.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://railway.com/railway.schema.json",
+  "build": {
+    "builder": "DOCKERFILE",
+    "dockerfilePath": "/services/react-word-editor/Dockerfile",
+    "watchPatterns": [
+      "/services/react-word-editor/**",
+      "/src/**",
+      "/test/fixtures/**",
+      "/package.json",
+      "/pnpm-lock.yaml",
+      "/pnpm-workspace.yaml"
+    ]
+  },
+  "deploy": {
+    "healthcheckPath": "/api/deploy-health",
+    "healthcheckTimeout": 60,
+    "restartPolicyType": "ON_FAILURE",
+    "restartPolicyMaxRetries": 10
+  }
+}

package/services/react-word-editor/scripts/wave-10-certification.mjs

@@ -0,0 +1,101 @@
+import { executeAutomatedSourceRun } from "../lib/run-artifacts.ts";
+import {
+  ensureWave10PendingSignoffArtifacts,
+  generateWave10RegressionArtifacts,
+  loadWave10CertificationManifest,
+  resolveRepoFreshnessState,
+  writeWave10SourceRunArtifact,
+} from "../lib/regression-report.ts";
+
+async function main() {
+  const [manifest, repoState] = await Promise.all([
+    loadWave10CertificationManifest(),
+    resolveRepoFreshnessState(),
+  ]);
+  const bundleId = `wave-10-${repoState.repoCommitSha?.slice(0, 12) ?? "local"}`;
+
+  await ensureWave10PendingSignoffArtifacts({
+    repoState,
+    bundleId,
+  });
+
+  const runSource = async (sourceKey, sourceKind) => {
+    const sourceId = `${sourceKind}:${sourceKey}`;
+    const result = await executeAutomatedSourceRun({
+      sourceId,
+      trigger: "proof-smoke",
+      proofWave: 10,
+      bundleId,
+      exportReason: `Wave 10 certification sweep for ${sourceId}.`,
+    });
+
+    await writeWave10SourceRunArtifact({
+      schemaVersion: "wave-10-source-run/1",
+      generatedAt: new Date().toISOString(),
+      sourceKey,
+      sourceId,
+      sourceKind,
+      proofContext: result.runStory.proofContext,
+      runStory: result.runStory,
+      source: result.source,
+      executionOutcome: result.executionOutcome,
+      compatibilitySummary: result.compatibilitySummary,
+      exportRecord: result.exportRecord
+        ? {
+            exportId: result.exportRecord.exportId,
+            fileName: result.exportRecord.fileName,
+            byteLength: result.exportRecord.byteLength,
+            createdAt: result.exportRecord.createdAt,
+          }
+        : undefined,
+      validationRun: result.validationRun
+        ? {
+            runId: result.validationRun.runId,
+            summary: result.validationRun.summary,
+            createdAt: result.validationRun.createdAt,
+          }
+        : undefined,
+      validationDeltaFromSource: result.runStory.validationArtifact?.deltaFromSource,
+    });
+
+    return {
+      sourceKey,
+      runId: result.runStory.runId,
+      state: result.executionOutcome.state,
+    };
+  };
+
+  const runSummaries = [];
+
+  for (const fixtureId of manifest.releaseGateFixtures) {
+    runSummaries.push(await runSource(fixtureId, "fixture"));
+  }
+
+  for (const scenarioId of manifest.representativeScenarios) {
+    runSummaries.push(await runSource(scenarioId, "scenario"));
+  }
+
+  const reports = await generateWave10RegressionArtifacts({
+    repoState,
+  });
+
+  console.log(
+    JSON.stringify(
+      {
+        bundleId,
+        repoState,
+        runs: runSummaries,
+        regression: reports.regression,
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+main().catch((error) => {
+  console.error(
+    error instanceof Error ? error.stack || error.message : "Wave 10 certification failed.",
+  );
+  process.exitCode = 1;
+});