CRDT for documents (2/6): Automerge engine core + full upstream interop parity

GNUmakefile

@@ -22,6 +22,7 @@ GOLINTCMD ?= golangci-lint
 SWIFTLINTCMD ?= swiftlint
 SWIFTCMD ?= swift
 RUST_TOOLCHAIN ?= 1.89.0
+AUTOMERGE_FUZZ_TIME ?= 10s
 SWIFT_ENROLL_UI ?= cmd/probo-agent/installer/macos/enroll-ui
 SWIFT_FORMAT_CONFIG ?= .swift-format
 SWIFTLINT_CONFIG ?= .swiftlint.yml
@@ -219,6 +220,34 @@ test-automerge-conformance: ## Test Go binary compatibility with official Autome
 	AUTOMERGE_JS_ORACLE=$(CURDIR)/packages/automerge-conformance/oracle.mjs \
 		$(GO_BASE) test -count=1 ./pkg/automerge
 
+.PHONY: audit-automerge-parity
+audit-automerge-parity: test-automerge-conformance
+audit-automerge-parity: ## Require every pinned upstream Automerge test to be mapped
+	AUTOMERGE_REQUIRE_FULL_PARITY=1 \
+		$(GO_BASE) test -count=1 -run '^TestUpstreamParityManifest$$' ./pkg/automerge
+
+.PHONY: audit-automerge-interop
+audit-automerge-interop: test-automerge-conformance
+audit-automerge-interop: ## Require complete Rust/JS wire and state interoperability
+	AUTOMERGE_REQUIRE_FULL_INTEROP=1 \
+		$(GO_BASE) test -count=1 -run '^TestUpstreamParityManifest$$' ./pkg/automerge
+
+.PHONY: benchmark-automerge
+benchmark-automerge: ## Benchmark native and Rust/WASM Automerge engines
+	$(GO_BASE) test -run '^$$' -bench . -benchmem ./pkg/automerge
+
+.PHONY: benchmark-automerge-native
+benchmark-automerge-native: ## Compare optimized native Go and native Rust
+	$(NPM) -w @probo/automerge-benchmark run compare
+
+.PHONY: fuzz-automerge
+fuzz-automerge: ## Fuzz Automerge public, wire, sync, and projection surfaces
+	$(GO_BASE) test -run '^$$' -fuzz '^FuzzLoad$$' -fuzztime=$(AUTOMERGE_FUZZ_TIME) ./pkg/automerge
+	$(GO_BASE) test -run '^$$' -fuzz '^FuzzCoreOperations$$' -fuzztime=$(AUTOMERGE_FUZZ_TIME) ./pkg/automerge
+	$(GO_BASE) test -run '^$$' -fuzz '^FuzzDecode$$' -fuzztime=$(AUTOMERGE_FUZZ_TIME) ./pkg/automerge/internal/native
+	$(GO_BASE) test -run '^$$' -fuzz '^FuzzParseSyncMessage$$' -fuzztime=$(AUTOMERGE_FUZZ_TIME) ./pkg/automerge/internal/native
+	$(GO_BASE) test -run '^$$' -fuzz '^FuzzRender$$' -fuzztime=$(AUTOMERGE_FUZZ_TIME) ./pkg/automerge/prosemirror
+
 .PHONY: coverage-report
 coverage-report: test ## Generate HTML coverage report
 	$(GO) tool cover -html=coverage.out -o coverage.html

go.mod

@@ -35,6 +35,7 @@ require (
 	github.com/pdfcpu/pdfcpu v0.13.0
 	github.com/pires/go-proxyproto v0.15.0
 	github.com/prometheus/client_golang v1.24.1
+	github.com/rivo/uniseg v0.4.7
 	github.com/scim2/filter-parser/v2 v2.3.1
 	github.com/sigstore/sigstore-go v1.3.0
 	github.com/stretchr/testify v1.11.1
@@ -137,7 +138,6 @@ require (
 	github.com/pb33f/ordered-map/v2 v2.3.1 // indirect
 	github.com/pjbgf/sha1cd v0.6.0 // indirect
 	github.com/q-uint/parser v0.3.1 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/secure-systems-lab/go-securesystemslib v0.11.0 // indirect
 	github.com/sergi/go-diff v1.4.0 // indirect
 	github.com/shibumi/go-pathspec v1.3.0 // indirect

packages/automerge-benchmark/.gitignore

@@ -0,0 +1,2 @@
+/rust/target/
+/go/probo-automerge-go-benchmark

packages/automerge-benchmark/compare.mjs

@@ -0,0 +1,167 @@
+// Copyright (c) 2026 Probo Inc <hello@probo.com>.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+const directory = path.dirname(fileURLToPath(import.meta.url));
+const repository = path.resolve(directory, "../..");
+const goBinary = path.join(os.tmpdir(), "probo-automerge-go-benchmark");
+const fixture = path.join(os.tmpdir(), "probo-automerge-benchmark-fixture");
+const rustManifest = path.join(directory, "rust", "Cargo.toml");
+const rustBinary = path.join(
+  directory,
+  "rust",
+  "target",
+  "release",
+  "probo-automerge-native-benchmark",
+);
+
+const scenarios = [
+  { workload: "create", size: 0, iterations: 100_000 },
+  { workload: "map", size: 100, iterations: 500 },
+  { workload: "map", size: 1_000, iterations: 30 },
+  { workload: "text", size: 100, iterations: 500 },
+  { workload: "text", size: 1_000, iterations: 30 },
+  { workload: "load", size: 10_000, iterations: 50 },
+  { workload: "save", size: 10_000, iterations: 1_000 },
+];
+const samples = 3;
+const goVersion = execFileSync("go", ["version"], { encoding: "utf8" }).trim();
+const rustVersion = execFileSync("rustc", ["+1.89.0", "--version"], {
+  encoding: "utf8",
+}).trim();
+
+execFileSync(
+  "go",
+  ["build", "-trimpath", "-ldflags=-s -w", "-o", goBinary, "./packages/automerge-benchmark/go"],
+  { cwd: repository, stdio: "inherit" },
+);
+execFileSync(
+  "cargo",
+  [
+    "+1.89.0",
+    "build",
+    "--release",
+    "--locked",
+    "--manifest-path",
+    rustManifest,
+  ],
+  { cwd: repository, stdio: "inherit" },
+);
+execFileSync(
+  goBinary,
+  [
+    "--workload",
+    "fixture",
+    "--size",
+    "10000",
+    "--fixture",
+    fixture,
+  ],
+  { stdio: "inherit" },
+);
+
+const rows = [];
+try {
+  for (const scenario of scenarios) {
+    const go = measure(goBinary, scenario);
+    const rust = measure(rustBinary, scenario);
+    if (go.checksum !== rust.checksum) {
+      throw new Error(
+        `checksum mismatch for ${scenario.workload}/${scenario.size}: Go ${go.checksum}, Rust ${rust.checksum}`,
+      );
+    }
+
+    rows.push({
+      workload: scenario.workload,
+      size: scenario.size,
+      goNS: go.ns,
+      rustNS: rust.ns,
+      ratio: rust.ns / go.ns,
+    });
+  }
+} finally {
+  fs.rmSync(goBinary, { force: true });
+  fs.rmSync(fixture, { force: true });
+}
+
+process.stdout.write(`Host: ${os.platform()}/${os.arch()} — ${os.cpus()[0]?.model ?? "unknown CPU"}\n`);
+process.stdout.write(`Go: ${goVersion}\n`);
+process.stdout.write(`Rust: ${rustVersion}\n`);
+process.stdout.write(`Samples: ${samples} (median reported)\n\n`);
+process.stdout.write("| Workload | Size | Native Go | Native Rust | Rust/Go |\n");
+process.stdout.write("|---|---:|---:|---:|---:|\n");
+for (const row of rows) {
+  process.stdout.write(
+    `| ${row.workload} | ${row.size || "—"} | ${duration(row.goNS)} | ${duration(row.rustNS)} | ${row.ratio.toFixed(2)}x |\n`,
+  );
+}
+
+function measure(binary, scenario) {
+  const values = [];
+  let checksum;
+  for (let sample = 0; sample < samples; sample++) {
+    const commandArguments = [
+      "--workload",
+      scenario.workload,
+      "--size",
+      String(scenario.size),
+      "--iterations",
+      String(scenario.iterations),
+      "--warmups",
+      "3",
+    ];
+    if (scenario.workload === "load" || scenario.workload === "save") {
+      commandArguments.push("--fixture", fixture);
+    }
+    const output = execFileSync(
+      binary,
+      commandArguments,
+      { encoding: "utf8" },
+    );
+    const result = JSON.parse(output);
+    values.push(Number(result.nsPerOp));
+    checksum ??= result.checksum;
+    if (checksum !== result.checksum) {
+      throw new Error(
+        `${binary} produced unstable checksums for ${scenario.workload}/${scenario.size}`,
+      );
+    }
+  }
+  values.sort((left, right) => left - right);
+  return {
+    checksum,
+    ns: values[Math.floor(values.length / 2)],
+  };
+}
+
+function duration(nanoseconds) {
+  if (nanoseconds < 1_000) return `${nanoseconds.toFixed(0)} ns`;
+  if (nanoseconds < 1_000_000) return `${(nanoseconds / 1_000).toFixed(2)} µs`;
+  if (nanoseconds < 1_000_000_000) {
+    return `${(nanoseconds / 1_000_000).toFixed(2)} ms`;
+  }
+  return `${(nanoseconds / 1_000_000_000).toFixed(2)} s`;
+}