test(affine): add 66-test suite; fix byte_to_hex, transform ordering

- Add tests/ covering ByteDetector (17), PathHandler (17),
  SafeWhitespace (13), TextTransform (19) — all 66 pass
- Fix byte_to_hex to handle multi-byte codepoints (>0xFF)
- Move normalize_line_endings to run after trim_lines_fn so JS
  .trim() cannot strip \r from CRLF-normalized lines
- Add scripts/build-all.sh; deno.json build-all delegates to it
  (deno task shell does not support POSIX for-in loops)
- Inject missing cross-module symbols into TextTransform.deno.js
  via post-compile Python patch (compiler issue #122 workaround):
  LF/CRLF/CR constants, is_invisible helper, concat alias

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: hyperpolymath

deno.json

@@ -4,7 +4,7 @@
   "exports": "./EmptyLinter.deno.js",
   "tasks": {
     "build": "affinescript compile --deno-esm EmptyLinter.affine -o EmptyLinter.deno.js && affinescript compile --deno-esm src/cli/Main.affine -o src/cli/Main.deno.js",
-    "build-all": "for f in stdlib/SafeHex.affine stdlib/SafeWhitespace.affine stdlib/SafePath.affine stdlib/SafeString.affine src/core/ByteDetector.affine src/core/TextTransform.affine src/core/PathHandler.affine EmptyLinter.affine src/cli/Main.affine; do affinescript compile --deno-esm $f -o ${f%.affine}.deno.js; done",
+    "build-all": "bash scripts/build-all.sh",
     "clean": "find . -name '*.deno.js' ! -path './stdlib/*' -delete",
     "dev": "while true; do affinescript compile --deno-esm EmptyLinter.affine -o EmptyLinter.deno.js 2>&1; sleep 2; done",
     "test": "deno test --allow-read --allow-write tests/",

deno.lock

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: MPL-2.0
+# SPDX-FileCopyrightText: 2026 hyperpolymath
+set -euo pipefail
+
+SOURCES=(
+  stdlib/SafeHex.affine
+  stdlib/SafeWhitespace.affine
+  stdlib/SafePath.affine
+  stdlib/SafeString.affine
+  src/core/ByteDetector.affine
+  src/core/TextTransform.affine
+  src/core/PathHandler.affine
+  EmptyLinter.affine
+  src/cli/Main.affine
+)
+
+for f in "${SOURCES[@]}"; do
+  affinescript compile --deno-esm "$f" -o "${f%.affine}.deno.js"
+done
+
+# Workaround: AffineScript alpha compiler (issue #122) does not fully inline
+# cross-module dependencies into TextTransform.deno.js. Inject missing symbols
+# after compilation: LF/CRLF/CR (zero-arg enum constructors), is_invisible
+# (private helper from SafeWhitespace), concat (string stdlib fn).
+python3 - << 'PYEOF'
+PATCH = """\
+const LF={tag:"LF"};const CRLF={tag:"CRLF"};const CR={tag:"CR"};
+function is_invisible(c){return(c===0||c===160||c===8203||c===65279||c===173||c===8206||c===8207||c===8204||c===8205||c===8288);}
+function concat(a,b){return __as_concat(a,b);}
+"""
+MARKER = "// ---- end runtime ----"
+path = "src/core/TextTransform.deno.js"
+with open(path) as fh:
+    content = fh.read()
+if PATCH.strip().split("\n")[0] not in content:
+    content = content.replace(MARKER, MARKER + "\n" + PATCH, 1)
+    with open(path, "w") as fh:
+        fh.write(content)
+PYEOF
+
+echo "build-all complete"

scripts/build-all.sh

@@ -52,7 +52,13 @@ pub fn get_artifact_def(byte_val: Int) -> Option<ArtifactDef> {
 }
 
 pub fn byte_to_hex(v: Int) -> String {
-  encode_byte(v & 255)
+  if v <= 255 {
+    encode_byte(v)
+  } else if v <= 65535 {
+    encode_byte((v >> 8) & 255) ++ encode_byte(v & 255)
+  } else {
+    encode_byte((v >> 16) & 255) ++ encode_byte((v >> 8) & 255) ++ encode_byte(v & 255)
+  }
 }
 
 pub fn scan(content: String) -> [Artifact] {

src/core/ByteDetector.affine

@@ -52,9 +52,6 @@ pub fn transform(content: String, options: TransformOptions) -> String {
   if options.remove_invisibles_opt {
     s = remove_invisibles(s);
   }
-  if options.normalize_line_endings_opt {
-    s = normalize_line_endings(s, options.target_line_ending);
-  }
   if options.collapse_spaces_opt {
     s = collapse_spaces(s);
   }
@@ -65,6 +62,9 @@ pub fn transform(content: String, options: TransformOptions) -> String {
   if options.trim_document {
     s = trim(s);
   }
+  if options.normalize_line_endings_opt {
+    s = normalize_line_endings(s, options.target_line_ending);
+  }
   if options.ensure_final_newline_opt {
     s = ensure_final_newline(s);
   }

src/core/TextTransform.affine

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: MPL-2.0
+// SPDX-FileCopyrightText: 2026 Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
+import { assertEquals } from "jsr:@std/assert";
+import {
+  validate, unwrap_path, path_join, sanitize,
+  is_within, get_parent, filename, has_extension,
+  is_excluded, from_trusted,
+  TraversalDetected,
+} from "../src/core/PathHandler.deno.js";
+
+Deno.test("PathHandler: validate accepts relative paths", () => {
+  const p = validate("src/main.affine");
+  assertEquals(p.tag, "Some");
+  assertEquals(unwrap_path(p.value), "src/main.affine");
+});
+
+Deno.test("PathHandler: validate rejects absolute paths", () => {
+  assertEquals(validate("/etc/passwd").tag, "None");
+});
+
+Deno.test("PathHandler: validate rejects path traversal", () => {
+  assertEquals(validate("../../etc/passwd").tag, "None");
+});
+
+Deno.test("PathHandler: validate rejects embedded traversal", () => {
+  assertEquals(validate("src/../../../etc").tag, "None");
+});
+
+Deno.test("PathHandler: sanitize removes dangerous characters", () => {
+  const clean = sanitize("file<name>.txt");
+  assertEquals(clean.includes("<"), false);
+  assertEquals(clean.includes(">"), false);
+});
+
+Deno.test("PathHandler: sanitize replaces slashes", () => {
+  const clean = sanitize("path/to/file");
+  assertEquals(clean.includes("/"), false);
+});
+
+Deno.test("PathHandler: path_join creates valid joined path", () => {
+  const base = from_trusted("docs");
+  const result = path_join(base, ["notes", "file.txt"]);
+  assertEquals(result.tag, "Ok");
+  assertEquals(unwrap_path(result.value), "docs/notes/file.txt");
+});
+
+Deno.test("PathHandler: path_join rejects traversal in components", () => {
+  const base = from_trusted("home");
+  const result = path_join(base, ["..", "..", "etc"]);
+  assertEquals(result.tag, "Err");
+  assertEquals(result.error.tag, "TraversalDetected");
+});
+
+Deno.test("PathHandler: filename extracts basename", () => {
+  const p = from_trusted("docs/reports/file.pdf");
+  assertEquals(filename(p), "file.pdf");
+});
+
+Deno.test("PathHandler: filename handles no directory", () => {
+  assertEquals(filename(from_trusted("file.txt")), "file.txt");
+});
+
+Deno.test("PathHandler: has_extension checks extension", () => {
+  const p = from_trusted("src/main.affine");
+  assertEquals(has_extension(p, ".affine"), true);
+  assertEquals(has_extension(p, ".js"), false);
+});
+
+Deno.test("PathHandler: get_parent extracts directory", () => {
+  const p = from_trusted("home/user/docs/file.txt");
+  const parent = get_parent(p);
+  assertEquals(parent.tag, "Some");
+  assertEquals(unwrap_path(parent.value), "home/user/docs");
+});
+
+Deno.test("PathHandler: get_parent returns None for no directory", () => {
+  assertEquals(get_parent(from_trusted("file.txt")).tag, "None");
+});
+
+Deno.test("PathHandler: is_within checks path containment", () => {
+  const p = from_trusted("home/user/docs");
+  const base = from_trusted("home/user");
+  assertEquals(is_within(p, base), true);
+});
+
+Deno.test("PathHandler: is_within rejects unrelated paths", () => {
+  const p = from_trusted("etc/passwd");
+  const base = from_trusted("home/user");
+  assertEquals(is_within(p, base), false);
+});
+
+Deno.test("PathHandler: is_excluded matches excluded dirs", () => {
+  const p = from_trusted("project/node_modules/pkg/index.js");
+  assertEquals(is_excluded(p, ["node_modules", ".git"]), true);
+});
+
+Deno.test("PathHandler: is_excluded allows non-excluded paths", () => {
+  const p = from_trusted("project/src/main.affine");
+  assertEquals(is_excluded(p, ["node_modules", ".git"]), false);
+});

tests/ByteDetector_test.js

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: MPL-2.0
+// SPDX-FileCopyrightText: 2026 Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
+import { assertEquals } from "jsr:@std/assert";
+import {
+  LF, CRLF, CR,
+  remove_invisibles, normalize_line_endings,
+  collapse_spaces, collapse_blank_lines,
+  trim_start, trim_end, ensure_final_newline,
+  detect_invisibles,
+} from "../stdlib/SafeWhitespace.deno.js";
+
+Deno.test("SafeWhitespace: trim_start removes leading whitespace", () => {
+  assertEquals(trim_start("  hello"), "hello");
+  assertEquals(trim_start("\t\nhello"), "hello");
+  assertEquals(trim_start("hello"), "hello");
+});
+
+Deno.test("SafeWhitespace: trim_end removes trailing whitespace", () => {
+  assertEquals(trim_end("hello  "), "hello");
+  assertEquals(trim_end("hello\t\n"), "hello");
+  assertEquals(trim_end("hello"), "hello");
+});
+
+Deno.test("SafeWhitespace: collapse_spaces reduces multiple spaces", () => {
+  assertEquals(collapse_spaces("hello    world"), "hello world");
+  assertEquals(collapse_spaces("a  b  c"), "a b c");
+});
+
+Deno.test("SafeWhitespace: collapse_spaces preserves single spaces", () => {
+  assertEquals(collapse_spaces("hello world"), "hello world");
+});
+
+Deno.test("SafeWhitespace: collapse_blank_lines reduces excess blank lines", () => {
+  const result = collapse_blank_lines("para1\n\n\n\npara2", 1);
+  assertEquals(result.includes("\n\n\n"), false);
+});
+
+Deno.test("SafeWhitespace: normalize_line_endings converts CRLF to LF", () => {
+  const result = normalize_line_endings("line1\r\nline2", LF);
+  assertEquals(result.includes("\r"), false);
+});
+
+Deno.test("SafeWhitespace: normalize_line_endings converts LF to CRLF", () => {
+  const result = normalize_line_endings("line1\nline2", CRLF);
+  assertEquals(result.includes("\r\n"), true);
+});
+
+Deno.test("SafeWhitespace: ensure_final_newline adds newline when missing", () => {
+  assertEquals(ensure_final_newline("hello").endsWith("\n"), true);
+});
+
+Deno.test("SafeWhitespace: ensure_final_newline idempotent when present", () => {
+  const result = ensure_final_newline("hello\n");
+  assertEquals(result, "hello\n");
+});
+
+Deno.test("SafeWhitespace: remove_invisibles strips known invisible chars", () => {
+  const result = remove_invisibles("​hello");
+  assertEquals(result.includes("​"), false);
+  assertEquals(result.includes(""), false);
+});
+
+Deno.test("SafeWhitespace: detect_invisibles finds NBSP", () => {
+  const found = detect_invisibles("hello world");
+  assertEquals(found.length, 1);
+  assertEquals(found[0], 0xa0);
+});
+
+Deno.test("SafeWhitespace: detect_invisibles empty for clean string", () => {
+  assertEquals(detect_invisibles("hello world").length, 0);
+});
+
+Deno.test("SafeWhitespace: LineEnding constants have correct tags", () => {
+  assertEquals(LF.tag, "LF");
+  assertEquals(CRLF.tag, "CRLF");
+  assertEquals(CR.tag, "CR");
+});