semantifold 0.5.0 → 0.6.0

package/node_modules/semantifold-tree-sitter-zig-internal/node_modules/tree-sitter/vendor/tree-sitter/lib/src/wasm_store.h

@@ -0,0 +1,31 @@
+#ifndef TREE_SITTER_WASM_H_
+#define TREE_SITTER_WASM_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "tree_sitter/api.h"
+#include "./parser.h"
+
+bool ts_wasm_store_start(TSWasmStore *self, TSLexer *lexer, const TSLanguage *language);
+void ts_wasm_store_reset(TSWasmStore *self);
+bool ts_wasm_store_has_error(const TSWasmStore *self);
+
+bool ts_wasm_store_call_lex_main(TSWasmStore *self, TSStateId state);
+bool ts_wasm_store_call_lex_keyword(TSWasmStore *self, TSStateId state);
+
+uint32_t ts_wasm_store_call_scanner_create(TSWasmStore *self);
+void ts_wasm_store_call_scanner_destroy(TSWasmStore *self, uint32_t scanner_address);
+bool ts_wasm_store_call_scanner_scan(TSWasmStore *self, uint32_t scanner_address, uint32_t valid_tokens_ix);
+uint32_t ts_wasm_store_call_scanner_serialize(TSWasmStore *self, uint32_t scanner_address, char *buffer);
+void ts_wasm_store_call_scanner_deserialize(TSWasmStore *self, uint32_t scanner, const char *buffer, unsigned length);
+
+void ts_wasm_language_retain(const TSLanguage *self);
+void ts_wasm_language_release(const TSLanguage *self);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_WASM_H_

package/node_modules/semantifold-tree-sitter-zig-internal/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "semantifold-tree-sitter-zig-internal",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Private parser-neutral Zig snapshots using Semantifold's isolated Tree-sitter runtime",
+  "type": "module",
+  "main": "./src/zig.js",
+  "files": [
+    "src/zig.js",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "@tree-sitter-grammars/tree-sitter-zig": "1.1.2",
+    "tree-sitter": "0.22.4"
+  }
+}

package/node_modules/semantifold-tree-sitter-zig-internal/src/zig.js

@@ -0,0 +1,134 @@
+// @ts-check
+
+import Parser from "tree-sitter"
+import ZigLanguage from "@tree-sitter-grammars/tree-sitter-zig"
+
+/** @typedef {Readonly<{row: number, column: number}>} CstPosition */
+/** @typedef {Readonly<{field: string | null, node: CstNode}>} CstChild */
+/**
+ * @typedef {Readonly<{
+ *   type: string,
+ *   named: boolean,
+ *   extra: boolean,
+ *   error: boolean,
+ *   missing: boolean,
+ *   hasError: boolean,
+ *   startIndex: number,
+ *   endIndex: number,
+ *   startPosition: CstPosition,
+ *   endPosition: CstPosition,
+ *   children: readonly CstChild[]
+ * }>} CstNode
+ */
+/** @typedef {Readonly<{schema: "semantifold.parser-cst", version: 1, language: "zig", root: CstNode}>} CstSnapshot */
+
+/**
+ * Parses the pinned Zig grammar with its isolated compatible runtime.
+ * @param {string} source - Caller-owned source text.
+ * @returns {CstSnapshot} Recursively frozen parser-neutral CST data.
+ */
+export function parseCst(source) {
+  const parser = new Parser()
+
+  // The grammar's declaration intentionally hides its native language handle as unknown.
+  parser.setLanguage(/** @type {Parser.Language} */ (/** @type {unknown} */ (ZigLanguage)))
+  const tree = parser.parse(source)
+  const convertIndex = createIndexConverter(source, tree.rootNode.endIndex)
+  const lineStarts = createLineStarts(source)
+  const root = snapshotNode(tree.rootNode, convertIndex, lineStarts)
+
+  parser.reset()
+  return Object.freeze({language: "zig", root, schema: "semantifold.parser-cst", version: 1})
+}
+
+/**
+ * @param {import("tree-sitter").SyntaxNode} node
+ * @param {(index: number) => number} convertIndex
+ * @param {readonly number[]} lineStarts
+ * @returns {CstNode}
+ */
+function snapshotNode(node, convertIndex, lineStarts) {
+  /** @type {CstChild[]} */
+  const children = []
+
+  for (let index = 0; index < node.childCount; index += 1) {
+    const child = node.child(index)
+
+    if (!child) throw new Error(`Zig Tree-sitter returned no child at index ${index}`)
+    children.push(Object.freeze({
+      field: node.fieldNameForChild(index) ?? null,
+      node: snapshotNode(child, convertIndex, lineStarts)
+    }))
+  }
+  const startIndex = convertIndex(node.startIndex)
+  const endIndex = convertIndex(node.endIndex)
+
+  return Object.freeze({
+    children: Object.freeze(children),
+    endIndex,
+    endPosition: positionForIndex(endIndex, lineStarts),
+    error: node.isError,
+    extra: node.isExtra,
+    hasError: node.hasError,
+    missing: node.isMissing,
+    named: node.isNamed,
+    startIndex,
+    startPosition: positionForIndex(startIndex, lineStarts),
+    type: node.type
+  })
+}
+
+/**
+ * Normalizes either UTF-8 byte offsets or UTF-16 offsets to UTF-16.
+ * @param {string} source
+ * @param {number} rootEndIndex
+ * @returns {(index: number) => number}
+ */
+function createIndexConverter(source, rootEndIndex) {
+  if (rootEndIndex == source.length) return (index) => index
+  const utf8Length = Buffer.byteLength(source, "utf8")
+
+  if (rootEndIndex != utf8Length) throw new Error(`Unsupported Zig Tree-sitter index extent ${rootEndIndex} for source length ${source.length}`)
+  /** @type {Map<number, number>} */
+  const byteToUtf16 = new Map([[0, 0]])
+  let byteIndex = 0
+
+  for (let utf16Index = 0; utf16Index < source.length;) {
+    const codePoint = source.codePointAt(utf16Index)
+
+    if (codePoint == null) throw new Error(`Cannot read source code point at index ${utf16Index}`)
+    const character = String.fromCodePoint(codePoint)
+
+    byteIndex += Buffer.byteLength(character, "utf8")
+    utf16Index += character.length
+    byteToUtf16.set(byteIndex, utf16Index)
+  }
+  return (index) => {
+    const converted = byteToUtf16.get(index)
+
+    if (converted == null) throw new Error(`Zig Tree-sitter returned a non-boundary byte index ${index}`)
+    return converted
+  }
+}
+
+/** @param {string} source @returns {readonly number[]} */
+function createLineStarts(source) {
+  const starts = [0]
+
+  for (let index = 0; index < source.length; index += 1) if (source[index] == "\n") starts.push(index + 1)
+  return starts
+}
+
+/** @param {number} index @param {readonly number[]} lineStarts @returns {CstPosition} */
+function positionForIndex(index, lineStarts) {
+  let low = 0
+  let high = lineStarts.length
+
+  while (low + 1 < high) {
+    const middle = Math.floor((low + high) / 2)
+
+    if (/** @type {number} */ (lineStarts[middle]) <= index) low = middle
+    else high = middle
+  }
+  return Object.freeze({column: index - /** @type {number} */ (lineStarts[low]), row: low})
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semantifold",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Language-neutral semantic code analysis, transformation, generation, and execution toolkit",
   "type": "module",
   "main": "build/index.js",
@@ -21,17 +21,18 @@
     "tsconfig.json"
   ],
   "workspaces": [
-    "packages/tree-sitter-legacy"
+    "packages/tree-sitter-legacy",
+    "packages/tree-sitter-zig"
   ],
   "scripts": {
     "all-checks": "npm run lint && npm test",
-    "build": "node scripts/clean-build.js && tsc && npm run build --workspace=semantifold-tree-sitter-legacy-workspace",
+    "build": "node scripts/clean-build.js && tsc && npm run build --workspace=semantifold-tree-sitter-legacy-workspace && npm run build --workspace=semantifold-tree-sitter-zig-workspace",
     "eslint": "eslint --max-warnings 0 .",
     "lint": "npm run verify:legacy-runtime && npm run eslint && npm run typecheck",
     "prepack": "npm run verify:legacy-runtime && npm run build",
-    "pretest": "npm run verify:legacy-runtime && npm run build --workspace=semantifold-tree-sitter-legacy-workspace",
+    "pretest": "npm run verify:legacy-runtime && npm run build --workspace=semantifold-tree-sitter-legacy-workspace && npm run build --workspace=semantifold-tree-sitter-zig-workspace",
     "test": "velocious-test spec",
-    "typecheck": "tsc --noEmit && npm run typecheck --workspace=semantifold-tree-sitter-legacy-workspace",
+    "typecheck": "tsc --noEmit && npm run typecheck --workspace=semantifold-tree-sitter-legacy-workspace && npm run typecheck --workspace=semantifold-tree-sitter-zig-workspace",
     "verify:legacy-runtime": "node scripts/verify-legacy-runtime.js"
   },
   "engines": {
@@ -58,6 +59,7 @@
     "comment-parser": "^1.4.1",
     "php-parser": "^3.7.0",
     "semantifold-tree-sitter-legacy-internal": "file:packages/tree-sitter-legacy/runtime",
+    "semantifold-tree-sitter-zig-internal": "file:packages/tree-sitter-zig/runtime",
     "tree-sitter": "0.25.1",
     "tree-sitter-c-sharp": "0.23.5",
     "tree-sitter-dart-orchard": "0.7.0",
@@ -68,10 +70,12 @@
   },
   "bundleDependencies": [
     "semantifold-tree-sitter-legacy-internal",
+    "semantifold-tree-sitter-zig-internal",
     "tree-sitter"
   ],
   "acceptDependencies": {
-    "semantifold-tree-sitter-legacy-internal": "0.1.0"
+    "semantifold-tree-sitter-legacy-internal": "0.1.0",
+    "semantifold-tree-sitter-zig-internal": "0.1.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
@@ -84,6 +88,7 @@
     "eslint-plugin-jsdoc-tag-lines": "^1.0.1",
     "globals": "^17.0.0",
     "semantifold-tree-sitter-legacy-workspace": "0.1.0",
+    "semantifold-tree-sitter-zig-workspace": "0.1.0",
     "typescript": "^7.0.0",
     "yaml": "^2.9.0"
   }

package/src/backends/android.js

@@ -17,7 +17,7 @@ const projectRoot = "generated/android-app"
 const generatorVersion = "0.4.0"
 /** @type {Readonly<Set<import("../semantic/types.js").SemanticLanguage>>} */
 const androidSourceLanguages = new Set([
-  "php", "ruby", "javascript", "typescript", "java", "kotlin", "python", "csharp", "go", "c", "cpp", "rust", "swift", "dart"
+  "php", "ruby", "javascript", "typescript", "java", "kotlin", "python", "csharp", "go", "c", "cpp", "rust", "swift", "dart", "zig"
 ])
 const requestFields = new Set(["assets", "configuration", "language", "module", "program", "resources", "role"])
 const configurationFields = new Set([
@@ -440,7 +440,11 @@ val semantifoldKotlinHome = providers.environmentVariable("SEMANTIFOLD_KOTLIN_HO
   ?: throw GradleException("SEMANTIFOLD_ANDROID_INFRASTRUCTURE: SEMANTIFOLD_KOTLIN_HOME is required")
 val semantifoldKotlinStdlib = file("$semantifoldKotlinHome/lib/kotlin-stdlib.jar")
 if (!semantifoldKotlinStdlib.isFile) {
-  throw GradleException("SEMANTIFOLD_ANDROID_INFRASTRUCTURE: pinned Kotlin compile library is missing")
+  throw GradleException("SEMANTIFOLD_ANDROID_INFRASTRUCTURE: pinned Kotlin stdlib is missing")
+}
+
+dependencies {
+  androidTestImplementation(files(semantifoldKotlinStdlib))
 }
 val semantifoldAcceptanceRoot = providers.environmentVariable("SEMANTIFOLD_ANDROID_ACCEPTANCE_ROOT").orNull
   ?: throw GradleException("SEMANTIFOLD_ANDROID_INFRASTRUCTURE: SEMANTIFOLD_ANDROID_ACCEPTANCE_ROOT is required")

package/src/backends/identifiers.js

@@ -9,6 +9,7 @@ const identifierPatterns = {
   kotlin: /^(?:_|\p{L})(?:_|\p{L}|\p{Nd})*$/u,
   swift: /^(?:_|\p{XID_Start})(?:_|\p{XID_Continue})*$/u,
   rust: /^[A-Za-z_][A-Za-z0-9_]*$/u,
+  zig: /^[A-Za-z_][A-Za-z0-9_]*$/u,
   cpp: /^[A-Za-z][A-Za-z0-9_]*$/u,
   c: /^[A-Za-z][A-Za-z0-9_]*$/u,
   csharp: /^[A-Za-z_][A-Za-z0-9_]*$/u,
@@ -60,6 +61,18 @@ const reservedWords = {
     "unsafe", "use", "where", "while", "abstract", "become", "box", "do", "final", "macro", "override", "priv", "typeof", "unsized", "virtual",
     "yield", "try", "union", "_", "main", "String", "std", "i64", "bool"
   ]),
+  zig: new Set([
+    "addrspace", "align", "allowzero", "and", "anyerror", "anyframe", "anyopaque", "anytype", "asm", "async", "await", "break", "callconv",
+    "catch", "comptime", "const", "continue", "defer", "else", "enum", "errdefer", "error", "export", "extern", "false",
+    "fn", "for", "if", "inline", "linksection", "noalias", "noinline", "nosuspend", "null", "opaque", "or", "orelse",
+    "packed", "pub", "resume", "return", "struct", "suspend", "switch", "test", "threadlocal", "true", "try", "union",
+    "unreachable", "usingnamespace", "var", "volatile", "while", "_", "main", "std", "bool", "c_char", "c_int", "c_long",
+    "c_longdouble", "c_longlong", "c_short", "c_uint", "c_ulong", "c_ulonglong", "c_ushort", "comptime_float",
+    "comptime_int", "f16", "f32", "f64", "f80", "f128", "isize", "noreturn", "type", "undefined", "usize", "void",
+    "semantifold_arena", "semantifold_fail", "semantifold_integer_add", "semantifold_integer_subtract",
+    "semantifold_integer_multiply", "semantifold_integer_negate", "semantifold_string_concat", "semantifold_string_equal",
+    "semantifold_string_not_equal", "semantifold_print_integer", "semantifold_print_boolean", "semantifold_print_string"
+  ]),
   cpp: new Set([
     "alignas", "alignof", "and", "and_eq", "asm", "auto", "bitand", "bitor", "bool", "break", "case", "catch", "char", "char8_t", "char16_t", "char32_t", "class", "compl", "concept", "const", "consteval", "constexpr", "constinit", "const_cast", "continue", "co_await", "co_return", "co_yield", "decltype", "default", "delete", "do", "double", "dynamic_cast", "else", "enum", "explicit", "export", "extern", "false", "float", "for", "friend", "goto", "if", "inline", "int", "long", "mutable", "namespace", "new", "noexcept", "not", "not_eq", "nullptr", "operator", "or", "or_eq", "private", "protected", "public", "register", "reinterpret_cast", "requires", "return", "short", "signed", "sizeof", "static", "static_assert", "static_cast", "struct", "switch", "template", "this", "thread_local", "throw", "true", "try", "typedef", "typeid", "typename", "union", "unsigned", "using", "virtual", "void", "volatile", "wchar_t", "while", "xor", "xor_eq", "std", "string", "numeric_limits",
     // The qualified libstdc++ <string> include chain also exposes these global names.
@@ -229,6 +242,7 @@ export function validateTargetIdentifier(language, name, role, location) {
     language == "python" && name.normalize("NFKC") != name ||
     language == "c" && !isCIdentifier(name) ||
     language == "rust" && !isRustIdentifier(name) ||
+    language == "zig" && !isZigIdentifier(name) ||
     language == "cpp" && !isCppIdentifier(name) ||
     language == "dart" && !isDartIdentifier(name) ||
     language == "swift" && (!isSwiftIdentifier(name) || name.normalize("NFC") != name) ||
@@ -307,6 +321,16 @@ export function isRustIdentifier(name) {
   return identifierPatterns.rust.test(name) && !reservedWords.rust.has(name) && !name.startsWith("semantifold_")
 }
 
+/**
+ * Protects Zig keywords, scalar names, entry plumbing, builtins, and the support namespace.
+ * @param {string} name - Caller-owned function or binding name.
+ * @returns {boolean} Whether ordinary unquoted Zig syntax can preserve the name.
+ */
+export function isZigIdentifier(name) {
+  return identifierPatterns.zig.test(name) && !reservedWords.zig.has(name) && !/^[iu][0-9]+$/u.test(name) &&
+    !name.startsWith("semantifold_")
+}
+
 /**
  * Protects Swift keywords, scalar names, entry plumbing, and target-only helper names.
  * @param {string} name - Caller-owned function or binding name.

package/src/backends/ios.js

@@ -13,7 +13,7 @@ import {SourceWriter} from "./writer.js"
 
 /** @type {Readonly<Set<import("../semantic/types.js").SemanticLanguage>>} */
 const iosSourceLanguages = new Set([
-  "php", "ruby", "javascript", "typescript", "java", "kotlin", "python", "csharp", "go", "c", "cpp", "rust", "swift", "dart"
+  "php", "ruby", "javascript", "typescript", "java", "kotlin", "python", "csharp", "go", "c", "cpp", "rust", "swift", "dart", "zig"
 ])
 const configurationFields = new Set([
   "bundleIdentifier", "capabilities", "deploymentTarget", "displayName", "entitlements", "infoPlist", "lifecycle",

package/src/backends/native-validation.js

@@ -10,7 +10,7 @@ const semanticEdges = new Set(["functions", "entryPoint", "body", "parameters",
 /**
  * Bounds a native occurrence plan and rejects cycles before recursive shared validation.
  * @param {unknown} module - Untrusted backend request.
- * @param {"c" | "cpp" | "kotlin" | "rust" | "swift" | "wasm"} [language] - Backend diagnostic language.
+ * @param {"c" | "cpp" | "kotlin" | "rust" | "swift" | "wasm" | "zig"} [language] - Backend diagnostic language.
  * @returns {void}
  */
 export function validateNativeGraph(module, language = "c") {

package/src/backends/scalars.js

@@ -2,6 +2,7 @@
 
 /** @type {Readonly<Record<import("../semantic/types.js").TextBackendLanguage, Readonly<Record<import("../semantic/types.js").FunctionReturnTypeName, string>>>>} */
 const targetScalarTypes = Object.freeze({
+  zig: Object.freeze({boolean: "bool", integer: "i64", string: "[]const u8", void: "void"}),
   dart: Object.freeze({boolean: "bool", integer: "int", string: "String", void: "void"}),
   swift: Object.freeze({boolean: "Bool", integer: "Int64", string: "String", void: "Void"}),
   rust: Object.freeze({boolean: "bool", integer: "i64", string: "String", void: "()"}),

package/src/backends/shared.js

@@ -27,7 +27,7 @@ const binaryOperationSyntax = Object.freeze({
   StringEqual: Object.freeze({default: "==", strict: "==="}),
   StringNotEqual: Object.freeze({default: "!=", strict: "!=="})
 })
-const task005Languages = new Set(["php", "ruby", "javascript", "typescript", "java", "dart"])
+const task005Languages = new Set(["php", "ruby", "javascript", "typescript", "java", "dart", "zig"])
 const task006Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const task007Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const task008Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
@@ -1952,9 +1952,9 @@ function validateKnownTargetInteger(expression, language, location) {
   if (language == "java" && value !== undefined && (value < -2147483648n || value > 2147483647n)) {
     unsupportedCapability(language, "compile-time-known integer operation outside signed 32-bit int range", location)
   }
-  if ((language == "csharp" || language == "go" || language == "c" || language == "cpp" || language == "rust" || language == "swift" || language == "wasm") && value !== undefined &&
+  if ((language == "csharp" || language == "go" || language == "c" || language == "cpp" || language == "rust" || language == "swift" || language == "wasm" || language == "zig") && value !== undefined &&
     (value < -9223372036854775808n || value > 9223372036854775807n)) {
-    const scalar = language == "wasm" ? "i64" : language == "swift" ? "Int64" : "long"
+    const scalar = language == "wasm" || language == "zig" ? "i64" : language == "swift" ? "Int64" : "long"
 
     unsupportedCapability(language, `compile-time-known integer operation outside signed 64-bit ${scalar} range`, location)
   }

package/src/backends/zig-runtime.js

@@ -0,0 +1,93 @@
+// @ts-check
+
+/** Exact Zig 0.15.2 standard-library-only support; the frontend checks every token before collapse. */
+export const zigRuntime = `const std = @import("std");
+
+var semantifold_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+
+fn semantifold_fail(message: []const u8) noreturn {
+    std.fs.File.stderr().writeAll(message) catch {};
+    std.process.exit(70);
+}
+
+fn semantifold_integer_add(left: i64, right: i64) i64 {
+    const result = @addWithOverflow(left, right);
+    if (result[1] != 0) semantifold_fail("semantifold: integer overflow\\n");
+    return result[0];
+}
+
+fn semantifold_integer_subtract(left: i64, right: i64) i64 {
+    const result = @subWithOverflow(left, right);
+    if (result[1] != 0) semantifold_fail("semantifold: integer overflow\\n");
+    return result[0];
+}
+
+fn semantifold_integer_multiply(left: i64, right: i64) i64 {
+    const result = @mulWithOverflow(left, right);
+    if (result[1] != 0) semantifold_fail("semantifold: integer overflow\\n");
+    return result[0];
+}
+
+fn semantifold_integer_negate(value: i64) i64 {
+    return semantifold_integer_subtract(0, value);
+}
+
+fn semantifold_string_concat(left: []const u8, right: []const u8) []const u8 {
+    const size = @addWithOverflow(left.len, right.len);
+    if (size[1] != 0) semantifold_fail("semantifold: allocation failure\\n");
+    const bytes = semantifold_arena.allocator().alloc(u8, size[0]) catch semantifold_fail("semantifold: allocation failure\\n");
+    @memcpy(bytes[0..left.len], left);
+    @memcpy(bytes[left.len..], right);
+    return bytes;
+}
+
+fn semantifold_string_equal(left: []const u8, right: []const u8) bool {
+    return std.mem.eql(u8, left, right);
+}
+
+fn semantifold_string_not_equal(left: []const u8, right: []const u8) bool {
+    return !std.mem.eql(u8, left, right);
+}
+
+fn semantifold_write(value: []const u8) void {
+    const stdout = std.fs.File.stdout();
+    stdout.writeAll(value) catch semantifold_fail("semantifold: output failure\\n");
+    stdout.writeAll("\\n") catch semantifold_fail("semantifold: output failure\\n");
+}
+
+fn semantifold_print_integer(value: i64) void {
+    var buffer: [20]u8 = undefined;
+    const bytes = std.fmt.bufPrint(&buffer, "{d}", .{value}) catch semantifold_fail("semantifold: output failure\\n");
+    semantifold_write(bytes);
+}
+
+fn semantifold_print_boolean(value: bool) void {
+    semantifold_write(if (value) "true" else "false");
+}
+
+fn semantifold_print_string(value: []const u8) void {
+    semantifold_write(value);
+}
+`
+
+/** Fixed native-host Zig build with only the selected optimization option and no package resolution. */
+export const zigBuild = `const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const optimize = b.standardOptimizeOption(.{});
+    const executable = b.addExecutable(.{
+        .name = "semantifold-generated",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/main.zig"),
+            .target = b.graph.host,
+            .optimize = optimize,
+        }),
+    });
+    b.installArtifact(executable);
+
+    const tests = b.addTest(.{ .root_module = executable.root_module });
+    const run_tests = b.addRunArtifact(tests);
+    const test_step = b.step("test", "Compile and run tests");
+    test_step.dependOn(&run_tests.step);
+}
+`

package/src/backends/zig-validation.js

@@ -0,0 +1,68 @@
+// @ts-check
+
+import {unsupportedCapability} from "../diagnostic.js"
+
+/** Repository-owned bound for frozen CST traversal and deterministic project generation. */
+export const maximumZigSourceLength = 1_000_000
+
+/**
+ * Rejects statically impossible UTF-8 arena sizes without changing the semantic graph.
+ * @param {import("../semantic/types.js").SemanticModule} module - Fully validated module.
+ * @returns {void}
+ */
+export function validateZigValues(module) {
+  /**
+   * Infers a known UTF-8 byte size while validating literal shape.
+   * @param {import("../semantic/types.js").Expression} expression - Expression to inspect.
+   * @param {Map<string, bigint | undefined>} sizes - Known binding sizes.
+   * @returns {bigint | undefined} Known byte size when statically available.
+   */
+  const size = (expression, sizes) => {
+    if (expression.kind == "IntegerLiteral" && (!Number.isSafeInteger(expression.value) || expression.value < 0 || Object.is(expression.value, -0))) {
+      unsupportedCapability("zig", "non-safe or noncanonical i64 literal", expression.location)
+    }
+    if (expression.kind == "StringLiteral") return BigInt(Buffer.byteLength(expression.value, "utf8"))
+    if (expression.kind == "IdentifierExpression") return sizes.get(expression.name)
+    if (expression.kind == "CallExpression") expression.arguments.forEach(argument => size(argument, sizes))
+    else if (expression.kind == "UnaryExpression") size(expression.operand, sizes)
+    else if (expression.kind == "BinaryExpression") {
+      const left = size(expression.left, sizes)
+      const right = size(expression.right, sizes)
+
+      if (expression.operation == "StringConcat") {
+        if ((left ?? 0n) + (right ?? 0n) > 9223372036854775807n) {
+          unsupportedCapability("zig", "known immutable UTF-8 slice exceeds the qualified native allocation limit", expression.location)
+        }
+        if (left !== undefined && right !== undefined) return left + right
+      }
+    }
+    return undefined
+  }
+  /**
+   * Propagates conservative known string sizes through one block.
+   * @param {import("../semantic/types.js").Block} block - Block to inspect.
+   * @param {Map<string, bigint | undefined>} inherited - Sizes visible on entry.
+   * @returns {Map<string, bigint | undefined>} Sizes known after the block.
+   */
+  const visit = (block, inherited) => {
+    const sizes = new Map(inherited)
+
+    for (const statement of block.statements) {
+      if (statement.kind == "LocalDeclaration") sizes.set(statement.name, size(statement.initializer, sizes))
+      else if (statement.kind == "AssignmentStatement") sizes.set(statement.target.name, size(statement.expression, sizes))
+      else if (statement.kind == "IfStatement") {
+        size(statement.condition, sizes)
+        const left = visit(statement.consequent, sizes)
+        const right = statement.alternate ? visit(statement.alternate, sizes) : sizes
+
+        for (const name of sizes.keys()) sizes.set(name, left.get(name) === right.get(name) ? left.get(name) : undefined)
+      } else if (statement.kind == "ExpressionStatement" || statement.kind == "PrintStatement" || statement.kind == "ReturnStatement") {
+        if (statement.expression) size(statement.expression, sizes)
+      }
+    }
+    return sizes
+  }
+
+  for (const declaration of module.functions) visit(declaration.body, new Map())
+  visit(module.entryPoint.body, new Map())
+}