Arborix -> Arboricx rename

ext/js/test/bundle.test.js

@@ -19,7 +19,7 @@ const fixtureDir = "../../test/fixtures";
 describe("bundle parsing", () => {
   it("valid bundle parses header and sections", () => {
     const bundle = parseBundle(
-      readFileSync(`${fixtureDir}/id.arborix`)
+      readFileSync(`${fixtureDir}/id.arboricx`)
     );
     strictEqual(bundle.version, "1.0");
     strictEqual(bundle.sectionCount, 2);
@@ -29,23 +29,23 @@ describe("bundle parsing", () => {
 
   it("parseManifest returns valid manifest", () => {
     const manifest = parseManifest(
-      readFileSync(`${fixtureDir}/id.arborix`)
+      readFileSync(`${fixtureDir}/id.arboricx`)
     );
-    strictEqual(manifest.schema, "arborix.bundle.manifest.v1");
+    strictEqual(manifest.schema, "arboricx.bundle.manifest.v1");
     strictEqual(manifest.bundleType, "tree-calculus-executable-object");
     strictEqual(manifest.closure, "complete");
     strictEqual(manifest.tree.calculus, "tree-calculus.v1");
     strictEqual(manifest.tree.nodeHash.algorithm, "sha256");
-    strictEqual(manifest.tree.nodeHash.domain, "arborix.merkle.node.v1");
+    strictEqual(manifest.tree.nodeHash.domain, "arboricx.merkle.node.v1");
     strictEqual(manifest.runtime.semantics, "tree-calculus.v1");
-    strictEqual(manifest.runtime.abi, "arborix.abi.tree.v1");
+    strictEqual(manifest.runtime.abi, "arboricx.abi.tree.v1");
   });
 });
 
 describe("hash verification", () => {
   it("valid bundle nodes verify", () => {
     const data = bundleParseNodeSection(
-      readFileSync(`${fixtureDir}/id.arborix`)
+      readFileSync(`${fixtureDir}/id.arboricx`)
     );
     const { nodeMap } = parseNodes(data);
     const { verified } = verifyNodeHashes(nodeMap);
@@ -62,20 +62,20 @@ describe("errors", () => {
 
   it("unsupported version fails", () => {
     const buf = Buffer.alloc(32, 0);
-    buf.write("ARBORIX\0", 0, 8);
+    buf.write("ARBORICX", 0, 8);
     buf.writeUInt16BE(2, 8); // major version 2
     throws(() => parseBundle(buf), /unsupported bundle major version/);
   });
 
   it("bad section digest fails", () => {
-    const buf = readFileSync(`${fixtureDir}/id.arborix`);
+    const buf = readFileSync(`${fixtureDir}/id.arboricx`);
     // Corrupt one byte in the manifest section
     buf[152] ^= 0x01;
     throws(() => parseBundle(buf), /digest mismatch/);
   });
 
   it("truncated bundle fails", () => {
-    const buf = readFileSync(`${fixtureDir}/id.arborix`);
+    const buf = readFileSync(`${fixtureDir}/id.arboricx`);
     const truncated = buf.slice(0, 40);
     throws(() => parseBundle(truncated), /truncated/);
   });
@@ -83,33 +83,33 @@ describe("errors", () => {
   it("missing nodes section fails", () => {
     // Build a bundle with only manifest entry in the directory (1 section instead of 2)
     const header = Buffer.alloc(32, 0);
-    header.write("ARBORIX\0", 0, 8);
+    header.write("ARBORICX", 0, 8);
     header.writeUInt16BE(1, 8);  // major version
     header.writeUInt16BE(0, 10); // minor version
     header.writeUInt32BE(1, 12); // 1 section
 
     // Build a manifest JSON
     const manifestObj = {
-      schema: "arborix.bundle.manifest.v1",
+      schema: "arboricx.bundle.manifest.v1",
       bundleType: "tree-calculus-executable-object",
       tree: {
         calculus: "tree-calculus.v1",
         nodeHash: {
           algorithm: "sha256",
-          domain: "arborix.merkle.node.v1"
+          domain: "arboricx.merkle.node.v1"
         },
-        nodePayload: "arborix.merkle.payload.v1"
+        nodePayload: "arboricx.merkle.payload.v1"
       },
       runtime: {
         semantics: "tree-calculus.v1",
         evaluation: "normal-order",
-        abi: "arborix.abi.tree.v1",
+        abi: "arboricx.abi.tree.v1",
         capabilities: []
       },
       closure: "complete",
       roots: [{ hash: Buffer.alloc(32).toString("hex"), role: "default" }],
-      exports: [{ name: "root", root: Buffer.alloc(32).toString("hex"), kind: "term", abi: "arborix.abi.tree.v1" }],
-      metadata: { createdBy: "arborix" }
+      exports: [{ name: "root", root: Buffer.alloc(32).toString("hex"), kind: "term", abi: "arboricx.abi.tree.v1" }],
+      metadata: { createdBy: "arboricx" }
     };
     const manifestJson = JSON.stringify(manifestObj);
     const manifestBytes = Buffer.from(manifestJson);

ext/js/test/merkle.test.js

@@ -51,35 +51,35 @@ describe("merkle — computeNodeHash", () => {
     strictEqual(hash.length, 64);
   });
 
-  it("Leaf hash matches expected Arborix domain", () => {
+  it("Leaf hash matches expected Arboricx domain", () => {
     const leaf = { type: "leaf" };
     const hash = computeNodeHash(leaf);
-    strictEqual(hash, "e54db458aa8e94782f7c61ad6c1f19a1c0c6fca7ffe53674f0d2bc5ff7ab02ff");
+    strictEqual(hash, "92b8a9796dbeafbcd36757535876256392170d137bf36b319d77f11a37112158");
   });
 });
 
 describe("merkle — node section parsing", () => {
   const fixtureDir = "../../test/fixtures";
 
-  it("parses id.arborix with correct node count", () => {
+  it("parses id.arboricx with correct node count", () => {
     const data = bundleParseNodeSection(
-      readFileSync(`${fixtureDir}/id.arborix`)
+      readFileSync(`${fixtureDir}/id.arboricx`)
     );
     const { nodeMap } = parseNodeSection(data);
     strictEqual(nodeMap.size, 4);
   });
 
-  it("parses true.arborix with correct node count", () => {
+  it("parses true.arboricx with correct node count", () => {
     const data = bundleParseNodeSection(
-      readFileSync(`${fixtureDir}/true.arborix`)
+      readFileSync(`${fixtureDir}/true.arboricx`)
     );
     const { nodeMap } = parseNodeSection(data);
     strictEqual(nodeMap.size, 2);
   });
 
-  it("parses false.arborix with correct node count", () => {
+  it("parses false.arboricx with correct node count", () => {
     const data = bundleParseNodeSection(
-      readFileSync(`${fixtureDir}/false.arborix`)
+      readFileSync(`${fixtureDir}/false.arboricx`)
     );
     const { nodeMap } = parseNodeSection(data);
     strictEqual(nodeMap.size, 1);
@@ -89,29 +89,29 @@ describe("merkle — node section parsing", () => {
 describe("merkle — hash verification", () => {
   const fixtureDir = "../../test/fixtures";
 
-  it("id.arborix nodes all verify", () => {
+  it("id.arboricx nodes all verify", () => {
     const data = bundleParseNodeSection(
-      readFileSync(`${fixtureDir}/id.arborix`)
+      readFileSync(`${fixtureDir}/id.arboricx`)
     );
     const { nodeMap } = parseNodeSection(data);
     const { verified, mismatches } = verifyNodeHashes(nodeMap);
-    ok(verified, "id.arborix node hashes should verify");
+    ok(verified, "id.arboricx node hashes should verify");
     strictEqual(mismatches.length, 0);
   });
 
-  it("true.arborix nodes all verify", () => {
+  it("true.arboricx nodes all verify", () => {
     const data = bundleParseNodeSection(
-      readFileSync(`${fixtureDir}/true.arborix`)
+      readFileSync(`${fixtureDir}/true.arboricx`)
     );
     const { nodeMap } = parseNodeSection(data);
     const { verified, mismatches } = verifyNodeHashes(nodeMap);
-    ok(verified, "true.arborix node hashes should verify");
+    ok(verified, "true.arboricx node hashes should verify");
     strictEqual(mismatches.length, 0);
   });
 
   it("corrupted node payload fails hash verification", () => {
     const data = bundleParseNodeSection(
-      readFileSync(`${fixtureDir}/id.arborix`)
+      readFileSync(`${fixtureDir}/id.arboricx`)
     );
     const { nodeMap } = parseNodeSection(data);
     // Find a stem node to corrupt
@@ -137,23 +137,23 @@ describe("merkle — hash verification", () => {
 describe("merkle — closure verification", () => {
   const fixtureDir = "../../test/fixtures";
 
-  it("id.arborix has complete closure", () => {
+  it("id.arboricx has complete closure", () => {
     const data = bundleParseNodeSection(
-      readFileSync(`${fixtureDir}/id.arborix`)
+      readFileSync(`${fixtureDir}/id.arboricx`)
     );
     const { nodeMap } = parseNodeSection(data);
     const { complete, missing } = verifyClosure(nodeMap);
-    ok(complete, "id.arborix should have complete closure");
+    ok(complete, "id.arboricx should have complete closure");
     strictEqual(missing.length, 0);
   });
 
   it("verifyRootClosure checks transitive reachability", () => {
     const data = bundleParseNodeSection(
-      readFileSync(`${fixtureDir}/id.arborix`)
+      readFileSync(`${fixtureDir}/id.arboricx`)
     );
     const { nodeMap } = parseNodeSection(data);
     // Use the actual root hash from the fixture's manifest
-    const manifest = parseManifest(readFileSync(`${fixtureDir}/id.arborix`));
+    const manifest = parseManifest(readFileSync(`${fixtureDir}/id.arboricx`));
     const rootHash = manifest.exports[0].root;
     const { complete, missingRoots } = verifyRootClosure(nodeMap, rootHash);
     ok(complete, "root should be reachable");
@@ -162,7 +162,7 @@ describe("merkle — closure verification", () => {
 
   it("parseNodeSection returns correct node count", () => {
     const data = bundleParseNodeSection(
-      readFileSync(`${fixtureDir}/id.arborix`)
+      readFileSync(`${fixtureDir}/id.arboricx`)
     );
     const result = parseNodeSection(data);
     strictEqual(result.count, 4);

ext/js/test/run-bundle.test.js

@@ -9,8 +9,8 @@ import { buildTreeFromNodeMap } from "../src/cli.js";
 
 const fixtureDir = "../../test/fixtures";
 
-describe("run bundle — id.arborix", () => {
-  const bundle = readFileSync(`${fixtureDir}/id.arborix`);
+describe("run bundle — id.arboricx", () => {
+  const bundle = readFileSync(`${fixtureDir}/id.arboricx`);
   const manifest = parseManifest(bundle);
   const nodeSectionData = bundleParseNodeSection(bundle);
   const { nodeMap } = parseNodes(nodeSectionData);
@@ -37,8 +37,8 @@ describe("run bundle — id.arborix", () => {
   });
 });
 
-describe("run bundle — true.arborix", () => {
-  const bundle = readFileSync(`${fixtureDir}/true.arborix`);
+describe("run bundle — true.arboricx", () => {
+  const bundle = readFileSync(`${fixtureDir}/true.arboricx`);
   const manifest = parseManifest(bundle);
   const nodeSectionData = bundleParseNodeSection(bundle);
   const { nodeMap } = parseNodes(nodeSectionData);
@@ -61,8 +61,8 @@ describe("run bundle — true.arborix", () => {
   });
 });
 
-describe("run bundle — false.arborix", () => {
-  const bundle = readFileSync(`${fixtureDir}/false.arborix`);
+describe("run bundle — false.arboricx", () => {
+  const bundle = readFileSync(`${fixtureDir}/false.arboricx`);
   const manifest = parseManifest(bundle);
   const nodeSectionData = bundleParseNodeSection(bundle);
   const { nodeMap } = parseNodes(nodeSectionData);
@@ -83,8 +83,8 @@ describe("run bundle — false.arborix", () => {
   });
 });
 
-describe("run bundle — notQ.arborix", () => {
-  const bundle = readFileSync(`${fixtureDir}/notQ.arborix`);
+describe("run bundle — notQ.arboricx", () => {
+  const bundle = readFileSync(`${fixtureDir}/notQ.arboricx`);
   const manifest = parseManifest(bundle);
   const nodeSectionData = bundleParseNodeSection(bundle);
   const { nodeMap } = parseNodes(nodeSectionData);
@@ -100,7 +100,7 @@ describe("run bundle — notQ.arborix", () => {
 });
 
 describe("run bundle — missing export", () => {
-  const bundle = readFileSync(`${fixtureDir}/id.arborix`);
+  const bundle = readFileSync(`${fixtureDir}/id.arboricx`);
   const manifest = parseManifest(bundle);
 
   it("nonexistent export fails clearly", () => {
@@ -109,8 +109,8 @@ describe("run bundle — missing export", () => {
 });
 
 describe("run bundle — auto-select", () => {
-  // true.arborix has only one export, should auto-select
-  const bundle = readFileSync(`${fixtureDir}/true.arborix`);
+  // true.arboricx has only one export, should auto-select
+  const bundle = readFileSync(`${fixtureDir}/true.arboricx`);
   const manifest = parseManifest(bundle);
 
   it("single export auto-selects", () => {