From 8769a91f0aebfe6228e32be1e15bf28858495800 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sat, 27 Dec 2025 14:10:50 +0000
Subject: [PATCH 1/2] =?UTF-8?q?feat(core):=20add=20known-good=20Bridge=20m?=
 =?UTF-8?q?odule=20with=20input=20=E2=86=92=20output=20=E2=86=92=20test?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add Bridge.res: ReScript module with transform, compose, prefix/suffix utilities
- Add rescript.json: compiler configuration for ESM output
- Add deno.json: task runner configuration for Deno environments
- Add package.json: npm scripts for Node.js fallback
- Add tests/bridge_test.mjs: 12 passing tests using Node.js test runner
- Update .gitignore: ignore compiled output and package-lock.json

The bridge demonstrates the core pattern:
  Input:  src/Bridge.res (ReScript)
  Output: lib/es6/src/Bridge.mjs (JavaScript ESM)
  Test:   node --test tests/bridge_test.mjs (12 tests pass)
---
 .gitignore            |  6 ++-
 deno.json             | 12 ++++++
 package.json          | 14 +++++++
 rescript.json         | 20 +++++++++
 src/Bridge.res        | 63 ++++++++++++++++++++++++++++
 tests/bridge_test.mjs | 96 +++++++++++++++++++++++++++++++++++++++++++
 6 files changed, 210 insertions(+), 1 deletion(-)
 create mode 100644 deno.json
 create mode 100644 package.json
 create mode 100644 rescript.json
 create mode 100644 src/Bridge.res
 create mode 100644 tests/bridge_test.mjs

diff --git a/.gitignore b/.gitignore
index 0338461..e834e1a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -38,8 +38,12 @@ erl_crash.dump
 /Manifest.toml
 
 # ReScript
-/lib/bs/
+/lib/
 /.bsb.lock
+.merlin
+
+# npm (fallback only - prefer Deno)
+package-lock.json
 
 # Python (SaltStack only)
 __pycache__/
diff --git a/deno.json b/deno.json
new file mode 100644
index 0000000..2d3ade3
--- /dev/null
+++ b/deno.json
@@ -0,0 +1,12 @@
+{
+  "$schema": "https://deno.land/x/deno/cli/schemas/config-file.v1.json",
+  "tasks": {
+    "build": "deno run -A npm:rescript@11.1.4 build",
+    "clean": "deno run -A npm:rescript@11.1.4 clean",
+    "test": "deno test --allow-read tests/",
+    "check": "deno task build && deno task test"
+  },
+  "imports": {
+    "rescript": "npm:rescript@11.1.4"
+  }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..a7c1702
--- /dev/null
+++ b/package.json
@@ -0,0 +1,14 @@
+{
+  "name": "bridge-web-rescript",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "build": "rescript build",
+    "clean": "rescript clean",
+    "test": "node --test tests/bridge_test.mjs",
+    "check": "npm run build && npm run test"
+  },
+  "devDependencies": {
+    "rescript": "^11.1.4"
+  }
+}
diff --git a/rescript.json b/rescript.json
new file mode 100644
index 0000000..551d821
--- /dev/null
+++ b/rescript.json
@@ -0,0 +1,20 @@
+{
+  "name": "bridge-web-rescript",
+  "sources": [
+    {
+      "dir": "src",
+      "subdirs": true
+    }
+  ],
+  "package-specs": [
+    {
+      "module": "esmodule",
+      "in-source": false
+    }
+  ],
+  "suffix": ".mjs",
+  "bs-dependencies": [],
+  "warnings": {
+    "number": "+A-48-42"
+  }
+}
diff --git a/src/Bridge.res b/src/Bridge.res
new file mode 100644
index 0000000..1514084
--- /dev/null
+++ b/src/Bridge.res
@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+// SPDX-FileCopyrightText: 2024 Hyperpolymath
+
+/**
+ * Bridge - A minimal input → output transformation module.
+ * Demonstrates the core pattern: receive input, transform, emit output.
+ */
+
+/** Result type for bridge operations */
+type bridgeResult<'a> = Ok('a) | Error(string)
+
+/** Bridge configuration */
+type config = {
+  name: string,
+  version: string,
+}
+
+/** Default configuration */
+let defaultConfig: config = {
+  name: "bridge",
+  version: "0.1.0",
+}
+
+/** Transform input string to output with bridge metadata */
+let transform = (input: string): string => {
+  `[bridge] ${input}`
+}
+
+/** Transform with result wrapper for error handling */
+let transformSafe = (input: string): bridgeResult<string> => {
+  if input == "" {
+    Error("Input cannot be empty")
+  } else {
+    Ok(transform(input))
+  }
+}
+
+/** Compose two transformations */
+let compose = (f: string => string, g: string => string): (string => string) => {
+  (input: string) => g(f(input))
+}
+
+/** Identity transform - returns input unchanged */
+let identity = (input: string): string => input
+
+/** Uppercase transform - binds to JavaScript String.toUpperCase */
+@send external toUpperCase: string => string = "toUpperCase"
+let uppercase = (input: string): string => input->toUpperCase
+
+/** Prefix transform factory */
+let prefix = (pre: string): (string => string) => {
+  (input: string) => `${pre}${input}`
+}
+
+/** Suffix transform factory */
+let suffix = (suf: string): (string => string) => {
+  (input: string) => `${input}${suf}`
+}
+
+/** Get bridge info */
+let info = (config: config): string => {
+  `${config.name} v${config.version}`
+}
diff --git a/tests/bridge_test.mjs b/tests/bridge_test.mjs
new file mode 100644
index 0000000..5d6d40f
--- /dev/null
+++ b/tests/bridge_test.mjs
@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+// SPDX-FileCopyrightText: 2024 Hyperpolymath
+
+/**
+ * Bridge module tests - verifies input → output transformations
+ */
+
+import { test, describe } from "node:test";
+import { strictEqual, deepStrictEqual } from "node:assert";
+import {
+  defaultConfig,
+  transform,
+  transformSafe,
+  compose,
+  identity,
+  uppercase,
+  prefix,
+  suffix,
+  info,
+} from "../lib/es6/src/Bridge.mjs";
+
+describe("Bridge", () => {
+  describe("transform", () => {
+    test("adds bridge prefix to input", () => {
+      strictEqual(transform("hello"), "[bridge] hello");
+    });
+
+    test("handles empty string", () => {
+      strictEqual(transform(""), "[bridge] ");
+    });
+  });
+
+  describe("transformSafe", () => {
+    test("returns Ok for valid input", () => {
+      const result = transformSafe("hello");
+      deepStrictEqual(result, { TAG: "Ok", _0: "[bridge] hello" });
+    });
+
+    test("returns Error for empty input", () => {
+      const result = transformSafe("");
+      deepStrictEqual(result, { TAG: "Error", _0: "Input cannot be empty" });
+    });
+  });
+
+  describe("compose", () => {
+    test("composes two functions left-to-right", () => {
+      const prefixHello = prefix("hello-");
+      const suffixWorld = suffix("-world");
+      const composed = compose(prefixHello, suffixWorld);
+      strictEqual(composed("test"), "hello-test-world");
+    });
+  });
+
+  describe("identity", () => {
+    test("returns input unchanged", () => {
+      strictEqual(identity("test"), "test");
+    });
+  });
+
+  describe("uppercase", () => {
+    test("converts string to uppercase", () => {
+      strictEqual(uppercase("hello"), "HELLO");
+    });
+  });
+
+  describe("prefix", () => {
+    test("creates a function that adds prefix", () => {
+      const addPrefix = prefix("pre-");
+      strictEqual(addPrefix("test"), "pre-test");
+    });
+  });
+
+  describe("suffix", () => {
+    test("creates a function that adds suffix", () => {
+      const addSuffix = suffix("-suf");
+      strictEqual(addSuffix("test"), "test-suf");
+    });
+  });
+
+  describe("info", () => {
+    test("returns formatted config info", () => {
+      strictEqual(info(defaultConfig), "bridge v0.1.0");
+    });
+
+    test("works with custom config", () => {
+      const customConfig = { name: "custom", version: "1.0.0" };
+      strictEqual(info(customConfig), "custom v1.0.0");
+    });
+  });
+
+  describe("defaultConfig", () => {
+    test("has correct default values", () => {
+      deepStrictEqual(defaultConfig, { name: "bridge", version: "0.1.0" });
+    });
+  });
+});

From d590e7faae40981882c31313c5e96bbf59fd9281 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sat, 27 Dec 2025 18:02:08 +0000
Subject: [PATCH 2/2] test(bridge): add contract tests for algebraic properties

- Add 25 contract tests verifying behavioral invariants:
  - Identity laws (unchanged input, idempotence)
  - Composition laws (left/right identity, associativity)
  - Transform contracts (prefix, length preservation)
  - transformSafe contracts (Ok/Error exhaustiveness)
  - Factory contracts (prefix/suffix return functions)
  - Uppercase contracts (idempotence, length preservation)
  - Info contracts (format verification)
  - Type preservation (all functions return strings)

- Update package.json test script to run all test files

Total: 37 tests (12 unit + 25 contract), all passing
---
 package.json                   |   2 +-
 tests/bridge_contract_test.mjs | 208 +++++++++++++++++++++++++++++++++
 2 files changed, 209 insertions(+), 1 deletion(-)
 create mode 100644 tests/bridge_contract_test.mjs

diff --git a/package.json b/package.json
index a7c1702..efaf633 100644
--- a/package.json
+++ b/package.json
@@ -5,7 +5,7 @@
   "scripts": {
     "build": "rescript build",
     "clean": "rescript clean",
-    "test": "node --test tests/bridge_test.mjs",
+    "test": "node --test tests/*.mjs",
     "check": "npm run build && npm run test"
   },
   "devDependencies": {
diff --git a/tests/bridge_contract_test.mjs b/tests/bridge_contract_test.mjs
new file mode 100644
index 0000000..e94031e
--- /dev/null
+++ b/tests/bridge_contract_test.mjs
@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+// SPDX-FileCopyrightText: 2024 Hyperpolymath
+
+/**
+ * Bridge Contract Tests
+ *
+ * These tests verify behavioral invariants and algebraic properties
+ * of the Bridge module, ensuring the API contracts are upheld.
+ */
+
+import { test, describe } from "node:test";
+import { strictEqual, deepStrictEqual, ok } from "node:assert";
+import {
+  transform,
+  transformSafe,
+  compose,
+  identity,
+  uppercase,
+  prefix,
+  suffix,
+  info,
+} from "../lib/es6/src/Bridge.mjs";
+
+describe("Bridge Contracts", () => {
+
+  describe("identity laws", () => {
+    test("identity returns input unchanged for any string", () => {
+      const testCases = ["", "hello", "  spaces  ", "123", "émoji 🎉", "\n\t"];
+      for (const input of testCases) {
+        strictEqual(identity(input), input, `identity(${JSON.stringify(input)}) should equal input`);
+      }
+    });
+
+    test("identity ∘ identity = identity (idempotent)", () => {
+      const input = "test";
+      strictEqual(identity(identity(input)), identity(input));
+    });
+  });
+
+  describe("composition laws", () => {
+    test("compose(f, identity) = f (right identity)", () => {
+      const f = prefix("pre-");
+      const composed = compose(f, identity);
+      const input = "test";
+      strictEqual(composed(input), f(input));
+    });
+
+    test("compose(identity, f) = f (left identity)", () => {
+      const f = suffix("-suf");
+      const composed = compose(identity, f);
+      const input = "test";
+      strictEqual(composed(input), f(input));
+    });
+
+    test("compose(f, compose(g, h)) = compose(compose(f, g), h) (associativity)", () => {
+      const f = prefix("a-");
+      const g = suffix("-b");
+      const h = uppercase;
+      const input = "x";
+
+      const leftAssoc = compose(f, compose(g, h));
+      const rightAssoc = compose(compose(f, g), h);
+
+      strictEqual(leftAssoc(input), rightAssoc(input));
+    });
+  });
+
+  describe("transform contracts", () => {
+    test("transform always prepends [bridge] prefix", () => {
+      const inputs = ["", "a", "hello world", "123"];
+      for (const input of inputs) {
+        ok(transform(input).startsWith("[bridge] "),
+           `transform(${JSON.stringify(input)}) should start with [bridge] `);
+      }
+    });
+
+    test("transform preserves input after prefix", () => {
+      const input = "original";
+      strictEqual(transform(input), "[bridge] " + input);
+    });
+
+    test("transform output length = input length + 9", () => {
+      const inputs = ["", "a", "hello"];
+      for (const input of inputs) {
+        strictEqual(transform(input).length, input.length + 9,
+          `transform adds exactly 9 characters ([bridge] )`);
+      }
+    });
+  });
+
+  describe("transformSafe contracts", () => {
+    test("transformSafe returns Error variant for empty string only", () => {
+      const result = transformSafe("");
+      strictEqual(result.TAG, "Error");
+    });
+
+    test("transformSafe returns Ok variant for non-empty strings", () => {
+      const inputs = [" ", "a", "test", "\n"];
+      for (const input of inputs) {
+        const result = transformSafe(input);
+        strictEqual(result.TAG, "Ok",
+          `transformSafe(${JSON.stringify(input)}) should return Ok`);
+      }
+    });
+
+    test("transformSafe Ok value equals transform output", () => {
+      const input = "test";
+      const result = transformSafe(input);
+      strictEqual(result._0, transform(input));
+    });
+
+    test("transformSafe result is exhaustive (Ok or Error)", () => {
+      const inputs = ["", "a", "test"];
+      for (const input of inputs) {
+        const result = transformSafe(input);
+        ok(result.TAG === "Ok" || result.TAG === "Error",
+          "Result must be Ok or Error");
+      }
+    });
+  });
+
+  describe("prefix/suffix factory contracts", () => {
+    test("prefix factory returns a function", () => {
+      strictEqual(typeof prefix("x"), "function");
+    });
+
+    test("suffix factory returns a function", () => {
+      strictEqual(typeof suffix("x"), "function");
+    });
+
+    test("prefix(a)(prefix(b)(x)) = prefix(a + b)(x) (prefix composition)", () => {
+      const input = "test";
+      const a = "first-";
+      const b = "second-";
+      strictEqual(prefix(a)(prefix(b)(input)), a + b + input);
+    });
+
+    test("suffix(a)(suffix(b)(x)) has both suffixes", () => {
+      const input = "test";
+      const result = suffix("-a")(suffix("-b")(input));
+      strictEqual(result, "test-b-a");
+    });
+
+    test("prefix with empty string is identity-like", () => {
+      const input = "test";
+      strictEqual(prefix("")(input), input);
+    });
+
+    test("suffix with empty string is identity-like", () => {
+      const input = "test";
+      strictEqual(suffix("")(input), input);
+    });
+  });
+
+  describe("uppercase contracts", () => {
+    test("uppercase is idempotent: uppercase(uppercase(x)) = uppercase(x)", () => {
+      const inputs = ["hello", "HELLO", "HeLLo", "123", ""];
+      for (const input of inputs) {
+        strictEqual(uppercase(uppercase(input)), uppercase(input),
+          `uppercase should be idempotent for ${JSON.stringify(input)}`);
+      }
+    });
+
+    test("uppercase preserves length", () => {
+      const inputs = ["hello", "test", "abc123"];
+      for (const input of inputs) {
+        strictEqual(uppercase(input).length, input.length);
+      }
+    });
+
+    test("uppercase of empty string is empty string", () => {
+      strictEqual(uppercase(""), "");
+    });
+  });
+
+  describe("info contracts", () => {
+    test("info output contains config name", () => {
+      const config = { name: "mybridge", version: "1.0.0" };
+      ok(info(config).includes(config.name));
+    });
+
+    test("info output contains config version", () => {
+      const config = { name: "mybridge", version: "2.5.3" };
+      ok(info(config).includes(config.version));
+    });
+
+    test("info format is 'name vversion'", () => {
+      const config = { name: "test", version: "1.0.0" };
+      strictEqual(info(config), "test v1.0.0");
+    });
+  });
+
+  describe("type preservation contracts", () => {
+    test("all transform functions return strings", () => {
+      const fns = [
+        () => transform("x"),
+        () => identity("x"),
+        () => uppercase("x"),
+        () => prefix("a")("x"),
+        () => suffix("b")("x"),
+        () => compose(identity, identity)("x"),
+      ];
+      for (const fn of fns) {
+        strictEqual(typeof fn(), "string", "Function should return string");
+      }
+    });
+  });
+});