From e582a146ae86a5fb2ff955638c9ac43009da8511 Mon Sep 17 00:00:00 2001
From: "Jonathan D.A. Jewell" <6759885+hyperpolymath@users.noreply.github.com>
Date: Mon, 24 Aug 2026 05:55:05 +0100
Subject: [PATCH] refactor: semantically port to AffineScript

---
 bindings/rescript/Bunsenite.affine      | 175 ++++++++++++++++-
 bindings/rescript/Bunsenite_test.affine | 183 ++++++++++++++++-
 bindings/rescript/Example.affine        | 249 +++++++++++++++++++++++-
 3 files changed, 598 insertions(+), 9 deletions(-)

diff --git a/bindings/rescript/Bunsenite.affine b/bindings/rescript/Bunsenite.affine
index d78ea0c..7a1072f 100644
--- a/bindings/rescript/Bunsenite.affine
+++ b/bindings/rescript/Bunsenite.affine
@@ -1,7 +1,176 @@
 // SPDX-License-Identifier: MPL-2.0
-// SPDX-FileCopyrightText: 2026 Jonathan D.A. Jewell
-// Ported via Harvard Engine bulk-processor
+// Ported via Harvard Engine (Semantic pass)
 
 module Bunsenite;
 
-// TODO: Complete semantic implementation
+// Bunsenite Rescript Bindings
+// Type-safe Rescript bindings for Bunsenite via C FFI
+//
+// Usage:
+//   open Bunsenite
+//   fn config = parseNickel("{foo = 42}", "config.ncl")
+//   Js.log(config)
+
+// External C FFI declarations
+// These bind to the C ABI provided by the Zig layer
+
+@module("./bunsenite_ffi")
+external parseNickelRaw: (string, string) => Js.Nullable.t<string> = "parse_nickel"
+
+@module("./bunsenite_ffi")
+external validateNickelRaw: (string, string) => int = "validate_nickel"
+
+@module("./bunsenite_ffi")
+external versionRaw: unit => string = "version"
+
+@module("./bunsenite_ffi")
+external rsrTierRaw: unit => string = "rsr_tier"
+
+@module("./bunsenite_ffi")
+external tpcfPerimeterRaw: unit => int = "tpcf_perimeter"
+
+// Result struct for error handling
+struct result<'a, 'e> = Ok('a) | Error('e)
+
+// Error struct
+struct error {
+  | ParseError(string)
+  | ValidationError(string)
+  | InvalidInput(string)
+
+// Parse and evaluate a Nickel configuration string
+//
+// Example:
+//   fn config = parseNickel("{name = \"example\", port = 8080}", "config.ncl")
+//   switch config {
+//   | Ok(json) => Js.log(json)
+//   | Error(err) => Js.log2("Error:", err)
+//   }
+fn parseNickel = (source: string, name: string): result<Js.Json.t, error> => {
+  fn result = parseNickelRaw(source, name)
+
+  switch Js.Nullable.toOption(result) {
+  | Some(jsonString) =>
+    try {
+      fn parsed = Js.Json.parseExn(jsonString)
+      Ok(parsed)
+    } catch {
+    | _ => Error(ParseError("Failed to parse JSON result"))
+    }
+  | None => Error(ParseError("Failed to parse Nickel configuration: " ++ name))
+  }
+}
+
+// Validate a Nickel configuration without evaluating it
+//
+// Example:
+//   fn result = validateNickel("{foo = 42}", "config.ncl")
+//   switch result {
+//   | Ok() => Js.log("Valid!")
+//   | Error(err) => Js.log2("Invalid:", err)
+//   }
+fn validateNickel = (source: string, name: string): result<unit, error> => {
+  fn resultCode = validateNickelRaw(source, name)
+
+  if resultCode == 0 {
+    Ok()
+  } else {
+    Error(ValidationError("Validation failed for: " ++ name))
+  }
+}
+
+// Get library version
+//
+// Example:
+//   fn ver = getVersion()
+//   Js.log2("Version:", ver)
+fn getVersion = (): string => {
+  versionRaw()
+}
+
+// Get RSR compliance tier
+//
+// Example:
+//   fn tier = getRSRTier()
+//   Js.log2("RSR Tier:", tier)
+fn getRSRTier = (): string => {
+  rsrTierRaw()
+}
+
+// Get TPCF perimeter number
+//
+// Example:
+//   fn perimeter = getTPCFPerimeter()
+//   Js.log2("TPCF Perimeter:", perimeter)
+fn getTPCFPerimeter = (): int => {
+  tpcfPerimeterRaw()
+}
+
+// Helper: Parse Nickel file from filesystem
+// Requires Node.js fs module
+//
+// Example:
+//   fn config = parseFile("./config.ncl")
+//   switch config {
+//   | Ok(json) => Js.log(json)
+//   | Error(err) => Js.log2("Error:", err)
+//   }
+@module("fs")
+external readFileSync: (string, string) => string = "readFileSync"
+
+fn parseFile = (path: string): result<Js.Json.t, error> => {
+  try {
+    fn source = readFileSync(path, "utf8")
+    parseNickel(source, path)
+  } catch {
+  | _ => Error(InvalidInput("Failed to read file: " ++ path))
+  }
+}
+
+// Helper: Validate Nickel file from filesystem
+//
+// Example:
+//   fn result = validateFile("./config.ncl")
+//   switch result {
+//   | Ok() => Js.log("Valid!")
+//   | Error(err) => Js.log2("Invalid:", err)
+//   }
+fn validateFile = (path: string): result<unit, error> => {
+  try {
+    fn source = readFileSync(path, "utf8")
+    validateNickel(source, path)
+  } catch {
+  | _ => Error(InvalidInput("Failed to read file: " ++ path))
+  }
+}
+
+// Helper: Get config value by key path
+// Example: getConfigValue(config, ["server", "port"])
+fn rec getConfigValue = (json: Js.Json.t, path: list<string>): option<Js.Json.t> => {
+  switch path {
+  | list{} => Some(json)
+  | list{key, ...rest} =>
+    switch Js.Json.decodeObject(json) {
+    | Some(obj) =>
+      switch Js.Dict.get(obj, key) {
+      | Some(value) => getConfigValue(value, rest)
+      | None => None
+      }
+    | None => None
+    }
+  }
+}
+
+// Helper: Convert error to string for display
+fn errorToString = (err: error): string => {
+  switch err {
+  | ParseError(msg) => "Parse Error: " ++ msg
+  | ValidationError(msg) => "Validation Error: " ++ msg
+  | InvalidInput(msg) => "Invalid Input: " ++ msg
+  }
+}
+
+// Re-export result struct for convenience
+struct parseResult { result<Js.Json.t, error>
+struct validateResult { result<unit, error>
+
diff --git a/bindings/rescript/Bunsenite_test.affine b/bindings/rescript/Bunsenite_test.affine
index f2e8172..3a4c9c0 100644
--- a/bindings/rescript/Bunsenite_test.affine
+++ b/bindings/rescript/Bunsenite_test.affine
@@ -1,7 +1,184 @@
 // SPDX-License-Identifier: MPL-2.0
-// SPDX-FileCopyrightText: 2026 Jonathan D.A. Jewell
-// Ported via Harvard Engine bulk-processor
+// Ported via Harvard Engine (Semantic pass)
 
 module Bunsenite_test;
 
-// TODO: Complete semantic implementation
+// SPDX-License-Identifier: MPL-2.0
+// Bunsenite ReScript Bindings Test Suite
+
+open Bunsenite
+
+// Test helpers
+fn assertEqual = (actual, expected, testName) => {
+  if actual == expected {
+    Console.log(`✓ ${testName}`)
+  } else {
+    Console.error(`✗ ${testName}`)
+    Console.error(`  Expected: ${expected->Js.Json.stringify}`)
+    Console.error(`  Actual: ${actual->Js.Json.stringify}`)
+  }
+}
+
+fn assertOk = (result, testName) => {
+  switch result {
+  | Ok(_) => Console.log(`✓ ${testName}`)
+  | Error(err) => {
+      Console.error(`✗ ${testName}`)
+      Console.error(`  Error: ${errorToString(err)}`)
+    }
+  }
+}
+
+fn assertError = (result, testName) => {
+  switch result {
+  | Error(_) => Console.log(`✓ ${testName}`)
+  | Ok(_) => Console.error(`✗ ${testName}: Expected error but got Ok`)
+  }
+}
+
+// Test suite
+fn runTests = () => {
+  Console.log("\n🧪 Bunsenite ReScript Bindings Test Suite\n")
+
+  // Test 1: Parse simple Nickel configuration
+  Console.log("Parse Tests:")
+  fn simpleConfig = parseNickel("{foo = 42}", "test.ncl")
+  assertOk(simpleConfig, "Parse simple number configuration")
+
+  // Test 2: Parse object configuration
+  fn objectConfig = parseNickel("{name = \"test\", value = 100}", "object.ncl")
+  assertOk(objectConfig, "Parse object configuration")
+
+  // Test 3: Parse nested configuration
+  fn nestedConfig = parseNickel("{server = {port = 8080, host = \"localhost\"}}", "nested.ncl")
+  assertOk(nestedConfig, "Parse nested configuration")
+
+  // Test 4: Parse array configuration
+  fn arrayConfig = parseNickel("{items = [1, 2, 3, 4, 5]}", "array.ncl")
+  assertOk(arrayConfig, "Parse array configuration")
+
+  // Test 5: Parse invalid syntax (should error)
+  fn invalidConfig = parseNickel("{foo = }", "invalid.ncl")
+  assertError(invalidConfig, "Parse invalid syntax returns error")
+
+  // Test 6: Parse empty configuration
+  fn emptyConfig = parseNickel("{}", "empty.ncl")
+  assertOk(emptyConfig, "Parse empty configuration")
+
+  // Validation Tests
+  Console.log("\nValidation Tests:")
+
+  fn validConfig = validateNickel("{foo = 42}", "valid.ncl")
+  assertOk(validConfig, "Validate correct configuration")
+
+  fn invalidValidation = validateNickel("{foo = }", "invalid-validate.ncl")
+  assertError(invalidValidation, "Validate incorrect configuration returns error")
+
+  // Test 7: Validate complex configuration
+  fn complexValid = validateNickel(
+    "{
+      app = {
+        name = \"example\",
+        version = \"1.0.0\",
+        config = {
+          debug = true,
+          port = 3000
+        }
+      }
+    }",
+    "complex.ncl",
+  )
+  assertOk(complexValid, "Validate complex nested configuration")
+
+  // Library Info Tests
+  Console.log("\nLibrary Info Tests:")
+
+  fn version = getVersion()
+  Console.log(`✓ Got version: ${version}`)
+
+  fn tier = getRSRTier()
+  Console.log(`✓ Got RSR tier: ${tier}`)
+
+  fn perimeter = getTPCFPerimeter()
+  Console.log(`✓ Got TPCF perimeter: ${perimeter->Int.toString}`)
+
+  // Config Value Tests
+  Console.log("\nConfig Value Extraction Tests:")
+
+  switch objectConfig {
+  | Ok(json) => {
+      // Test extracting top-level value
+      fn nameValue = getConfigValue(json, list{"name"})
+      switch nameValue {
+      | Some(_) => Console.log("✓ Extract top-level value")
+      | None => Console.error("✗ Failed to extract top-level value")
+      }
+
+      // Test extracting non-existent value
+      fn missingValue = getConfigValue(json, list{"missing"})
+      switch missingValue {
+      | None => Console.log("✓ Non-existent value returns None")
+      | Some(_) => Console.error("✗ Non-existent value should return None")
+      }
+    }
+  | Error(_) => Console.error("✗ Could not test config value extraction")
+  }
+
+  switch nestedConfig {
+  | Ok(json) => {
+      // Test extracting nested value
+      fn portValue = getConfigValue(json, list{"server", "port"})
+      switch portValue {
+      | Some(_) => Console.log("✓ Extract nested value")
+      | None => Console.error("✗ Failed to extract nested value")
+      }
+
+      // Test extracting with invalid path
+      fn invalidPath = getConfigValue(json, list{"server", "nonexistent", "deep"})
+      switch invalidPath {
+      | None => Console.log("✓ Invalid nested path returns None")
+      | Some(_) => Console.error("✗ Invalid path should return None")
+      }
+    }
+  | Error(_) => Console.error("✗ Could not test nested value extraction")
+  }
+
+  // Error handling tests
+  Console.log("\nError Handling Tests:")
+
+  fn parseErr = parseNickel("{invalid syntax here}", "error-test.ncl")
+  switch parseErr {
+  | Error(err) => {
+      fn errStr = errorToString(err)
+      Console.log(`✓ Error converted to string: ${errStr}`)
+    }
+  | Ok(_) => Console.error("✗ Expected parse error")
+  }
+
+  // Result struct tests
+  Console.log("\nResult Type Tests:")
+
+  fn successResult: parseResult = Ok(Js.Json.null)
+  switch successResult {
+  | Ok(_) => Console.log("✓ parseResult Ok variant works")
+  | Error(_) => Console.error("✗ parseResult Ok variant failed")
+  }
+
+  fn errorResult: parseResult = Error(ParseError("test"))
+  switch errorResult {
+  | Error(_) => Console.log("✓ parseResult Error variant works")
+  | Ok(_) => Console.error("✗ parseResult Error variant failed")
+  }
+
+  fn validateSuccess: validateResult = Ok()
+  switch validateSuccess {
+  | Ok() => Console.log("✓ validateResult Ok variant works")
+  | Error(_) => Console.error("✗ validateResult Ok variant failed")
+  }
+
+  Console.log("\n✅ Test suite complete\n")
+}
+
+// Run tests
+runTests()
+
diff --git a/bindings/rescript/Example.affine b/bindings/rescript/Example.affine
index ce13ad7..790537f 100644
--- a/bindings/rescript/Example.affine
+++ b/bindings/rescript/Example.affine
@@ -1,7 +1,250 @@
 // SPDX-License-Identifier: MPL-2.0
-// SPDX-FileCopyrightText: 2026 Jonathan D.A. Jewell
-// Ported via Harvard Engine bulk-processor
+// Ported via Harvard Engine (Semantic pass)
 
 module Example;
 
-// TODO: Complete semantic implementation
+// SPDX-License-Identifier: MPL-2.0
+// Bunsenite ReScript Bindings Example
+
+open Bunsenite
+
+// Example 1: Simple parsing
+fn example1 = () => {
+  Console.log("\n📝 Example 1: Simple Configuration Parsing\n")
+
+  fn config = parseNickel(
+    "{
+      app_name = \"my-application\",
+      version = \"1.0.0\",
+      port = 8080
+    }",
+    "app-config.ncl",
+  )
+
+  switch config {
+  | Ok(json) => {
+      Console.log("✓ Configuration parsed successfully!")
+      Console.log(Js.Json.stringify(json))
+
+      // Extract specific values
+      switch getConfigValue(json, list{"app_name"}) {
+      | Some(name) => Console.log(`App name: ${Js.Json.stringify(name)}`)
+      | None => Console.log("App name not found")
+      }
+
+      switch getConfigValue(json, list{"port"}) {
+      | Some(port) => Console.log(`Port: ${Js.Json.stringify(port)}`)
+      | None => Console.log("Port not found")
+      }
+    }
+  | Error(err) => Console.error(`✗ Parse error: ${errorToString(err)}`)
+  }
+}
+
+// Example 2: Nested configuration
+fn example2 = () => {
+  Console.log("\n📝 Example 2: Nested Configuration\n")
+
+  fn config = parseNickel(
+    "{
+      server = {
+        host = \"0.0.0.0\",
+        port = 3000,
+        tls = {
+          enabled = true,
+          cert_path = \"/path/to/cert.pem\"
+        }
+      },
+      database = {
+        host = \"localhost\",
+        port = 5432,
+        name = \"myapp\"
+      }
+    }",
+    "server-config.ncl",
+  )
+
+  switch config {
+  | Ok(json) => {
+      Console.log("✓ Nested configuration parsed!")
+
+      // Extract deeply nested values
+      switch getConfigValue(json, list{"server", "tls", "enabled"}) {
+      | Some(tls) => Console.log(`TLS enabled: ${Js.Json.stringify(tls)}`)
+      | None => Console.log("TLS setting not found")
+      }
+
+      switch getConfigValue(json, list{"database", "name"}) {
+      | Some(dbName) => Console.log(`Database name: ${Js.Json.stringify(dbName)}`)
+      | None => Console.log("Database name not found")
+      }
+    }
+  | Error(err) => Console.error(`✗ Parse error: ${errorToString(err)}`)
+  }
+}
+
+// Example 3: Validation before parsing
+fn example3 = () => {
+  Console.log("\n📝 Example 3: Configuration Validation\n")
+
+  fn configSource = "{
+    api_key = \"secret-key-123\",
+    timeout = 30,
+    retries = 3
+  }"
+
+  // First validate
+  fn validation = validateNickel(configSource, "api-config.ncl")
+
+  switch validation {
+  | Ok() => {
+      Console.log("✓ Configuration is valid, proceeding to parse...")
+
+      // Now parse
+      switch parseNickel(configSource, "api-config.ncl") {
+      | Ok(json) => {
+          Console.log("✓ Configuration parsed successfully!")
+          Console.log(Js.Json.stringify(json))
+        }
+      | Error(err) => Console.error(`✗ Parse error: ${errorToString(err)}`)
+      }
+    }
+  | Error(err) => Console.error(`✗ Validation failed: ${errorToString(err)}`)
+  }
+}
+
+// Example 4: Error handling
+fn example4 = () => {
+  Console.log("\n📝 Example 4: Error Handling\n")
+
+  fn invalidConfig = "{
+    this is not = valid nickel syntax
+  }"
+
+  fn result = parseNickel(invalidConfig, "bad-config.ncl")
+
+  switch result {
+  | Ok(json) => {
+      Console.log("Parsed (unexpected):")
+      Console.log(Js.Json.stringify(json))
+    }
+  | Error(ParseError(msg)) => {
+      Console.log(`✓ Caught parse error: ${msg}`)
+      Console.log("This is expected - the syntax was invalid")
+    }
+  | Error(ValidationError(msg)) => Console.log(`Validation error: ${msg}`)
+  | Error(InvalidInput(msg)) => Console.log(`Invalid input: ${msg}`)
+  }
+}
+
+// Example 5: Array configuration
+fn example5 = () => {
+  Console.log("\n📝 Example 5: Array Configuration\n")
+
+  fn config = parseNickel(
+    "{
+      users = [
+        \"alice\",
+        \"bob\",
+        \"charlie\"
+      ],
+      ports = [8080, 8081, 8082],
+      features = {
+        enabled = [\"auth\", \"logging\", \"metrics\"]
+      }
+    }",
+    "array-config.ncl",
+  )
+
+  switch config {
+  | Ok(json) => {
+      Console.log("✓ Array configuration parsed!")
+
+      switch getConfigValue(json, list{"users"}) {
+      | Some(users) => Console.log(`Users: ${Js.Json.stringify(users)}`)
+      | None => Console.log("Users not found")
+      }
+
+      switch getConfigValue(json, list{"features", "enabled"}) {
+      | Some(features) => Console.log(`Enabled features: ${Js.Json.stringify(features)}`)
+      | None => Console.log("Features not found")
+      }
+    }
+  | Error(err) => Console.error(`✗ Parse error: ${errorToString(err)}`)
+  }
+}
+
+// Example 6: Library information
+fn example6 = () => {
+  Console.log("\n📝 Example 6: Library Information\n")
+
+  Console.log(`Bunsenite version: ${getVersion()}`)
+  Console.log(`RSR compliance tier: ${getRSRTier()}`)
+  Console.log(`TPCF perimeter: ${getTPCFPerimeter()->Int.toString}`)
+}
+
+// Example 7: Type-safe configuration with pattern matching
+fn example7 = () => {
+  Console.log("\n📝 Example 7: Type-Safe Configuration Access\n")
+
+  fn config = parseNickel(
+    "{
+      mode = \"production\",
+      debug = false,
+      log_level = \"info\"
+    }",
+    "env-config.ncl",
+  )
+
+  // Type-safe access with exhaustive pattern matching
+  fn mode = switch config {
+  | Ok(json) =>
+    switch getConfigValue(json, list{"mode"}) {
+    | Some(value) =>
+      switch Js.Json.classify(value) {
+      | JSONString(str) => Some(str)
+      | _ => None
+      }
+    | None => None
+    }
+  | Error(_) => None
+  }
+
+  switch mode {
+  | Some("production") => Console.log("✓ Running in production mode")
+  | Some("development") => Console.log("Running in development mode")
+  | Some(other) => Console.log(`Running in ${other} mode`)
+  | None => Console.log("Mode not specified")
+  }
+}
+
+// Run all examples
+fn runExamples = () => {
+  Console.log("🎯 Bunsenite ReScript Bindings Examples")
+  Console.log("=" |> Js.String.repeat(50))
+
+  example1()
+  example2()
+  example3()
+  example4()
+  example5()
+  example6()
+  example7()
+
+  Console.log("\n✅ All examples completed!\n")
+}
+
+// Export for use in other files
+fn examples = [
+  ("simple", example1),
+  ("nested", example2),
+  ("validation", example3),
+  ("error-handling", example4),
+  ("arrays", example5),
+  ("library-info", example6),
+  ("struct-safe", example7),
+]
+
+// Run if executed directly
+runExamples()
+