semantifold 0.4.0 → 0.6.0

package/src/backends/identifiers.js

@@ -4,10 +4,12 @@ import {unsupportedCapability} from "../diagnostic.js"
 
 /** @type {Record<Exclude<import("../semantic/types.js").BackendLanguage, "ios">, RegExp>} */
 const identifierPatterns = {
+  android: /^(?:_|\p{L})(?:_|\p{L}|\p{Nd})*$/u,
   dart: /^(?:_|\p{L})(?:_|\p{L}|\p{Nd})*$/u,
   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,
@@ -23,6 +25,11 @@ const identifierPatterns = {
 
 /** @type {Record<Exclude<import("../semantic/types.js").BackendLanguage, "ios">, Set<string>>} */
 const reservedWords = {
+  android: new Set([
+    "as", "break", "class", "continue", "do", "else", "false", "for", "fun", "if", "in", "interface", "is", "null",
+    "object", "package", "return", "super", "this", "throw", "true", "try", "typealias", "typeof", "val", "var", "when",
+    "while", "_", "main", "println", "Long", "Boolean", "String", "Math", "ArithmeticException"
+  ]),
   dart: new Set([
     "Function", "Never", "Object", "RangeError", "String", "abstract", "as", "assert", "async", "await", "base",
     "bool", "break", "case", "catch", "class", "const", "continue", "covariant", "default", "deferred", "do",
@@ -54,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.
@@ -223,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) ||
@@ -301,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/kotlin.js

@@ -47,12 +47,12 @@ export function generateKotlin(module, writer) {
     writer.mapped(emitScalarType("kotlin", declaration.returnType), {mappingKind: "exact", node: declaration.returnType,
       path: `${path}/returnType`, role: "type"})
     writer.synthetic(" {\n", "Kotlin function body scaffold", [declaration], [path])
-    emitBlock(writer, declaration.body, "  ", `${path}/body`)
+    emitKotlinBlock(writer, declaration.body, "  ", `${path}/body`)
     writer.synthetic("}\n", "Kotlin function body scaffold", [declaration], [path])
   })
 
   writer.synthetic("\nfun main() {\n", "Kotlin generated main scaffold", [module.entryPoint], ["/entryPoint"])
-  emitBlock(writer, module.entryPoint.body, "  ", "/entryPoint/body")
+  emitKotlinBlock(writer, module.entryPoint.body, "  ", "/entryPoint/body")
   writer.synthetic("}\n", "Kotlin generated main scaffold", [module.entryPoint], ["/entryPoint"])
 }
 
@@ -62,10 +62,12 @@ export function generateKotlin(module, writer) {
  * @param {import("../semantic/types.js").Block} block - Semantic block.
  * @param {string} indent - Current indentation.
  * @param {string} path - Semantic block path.
+ * @param {string} [printTarget] - Target-owned print function spelling.
  * @returns {void}
  */
-function emitBlock(writer, block, indent, path) {
-  block.statements.forEach((statement, index) => emitStatement(writer, statement, indent, `${path}/statements/${index}`))
+export function emitKotlinBlock(writer, block, indent, path, printTarget = "println") {
+  block.statements.forEach((statement, index) =>
+    emitKotlinStatement(writer, statement, indent, `${path}/statements/${index}`, printTarget))
 }
 
 /**
@@ -74,9 +76,10 @@ function emitBlock(writer, block, indent, path) {
  * @param {import("../semantic/types.js").Statement} statement - Semantic statement.
  * @param {string} indent - Current indentation.
  * @param {string} path - Semantic statement path.
+ * @param {string} printTarget - Target-owned print function spelling.
  * @returns {void}
  */
-function emitStatement(writer, statement, indent, path) {
+function emitKotlinStatement(writer, statement, indent, path, printTarget) {
   writer.synthetic(indent, "indentation", [statement], [path])
   if (statement.kind == "LocalDeclaration") {
     writer.mapped(statement.mutable ? "var" : "val", {mappingKind: "anchor", node: statement, path})
@@ -111,7 +114,7 @@ function emitStatement(writer, statement, indent, path) {
     return
   }
   if (statement.kind == "PrintStatement") {
-    writer.synthetic("println(", "Kotlin println plumbing", [statement], [path])
+    writer.synthetic(`${printTarget}(`, "Kotlin print plumbing", [statement], [path])
     emitExpression(writer, statement.expression, `${path}/expression`, "kotlin", identity)
     writer.synthetic(")\n", "Kotlin println plumbing", [statement], [path])
     return
@@ -121,11 +124,11 @@ function emitStatement(writer, statement, indent, path) {
   writer.synthetic(" (", "Kotlin conditional scaffold", [statement], [path])
   emitExpression(writer, statement.condition, `${path}/condition`, "kotlin", identity)
   writer.synthetic(") {\n", "Kotlin conditional scaffold", [statement.consequent], [`${path}/consequent`])
-  emitBlock(writer, statement.consequent, `${indent}  `, `${path}/consequent`)
+  emitKotlinBlock(writer, statement.consequent, `${indent}  `, `${path}/consequent`, printTarget)
   writer.synthetic(`${indent}}`, "Kotlin conditional scaffold", [statement.consequent], [`${path}/consequent`])
   if (statement.alternate) {
     writer.synthetic(" else {\n", "Kotlin alternate scaffold", [statement.alternate], [`${path}/alternate`])
-    emitBlock(writer, statement.alternate, `${indent}  `, `${path}/alternate`)
+    emitKotlinBlock(writer, statement.alternate, `${indent}  `, `${path}/alternate`, printTarget)
     writer.synthetic(`${indent}}`, "Kotlin alternate scaffold", [statement.alternate], [`${path}/alternate`])
   }
   writer.synthetic("\n", "line break", [statement], [path])

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/program.js

@@ -23,7 +23,7 @@ import {programImportName, SourceWriter} from "./writer.js"
 /** @type {Readonly<Set<import("../semantic/types.js").SemanticLanguage>>} */
 const programTargets = new Set(["php", "ruby", "javascript", "typescript", "java"])
 /** @type {Readonly<Set<import("../semantic/types.js").BackendLanguage>>} */
-const programApplicationTargets = new Set(["ios"])
+const programApplicationTargets = new Set(["android", "ios"])
 
 /**
  * Validates and prepares a complete semantic program for a non-text backend without allocating a writer.
@@ -68,8 +68,9 @@ export function preflightSemanticProgram({backendLanguage, diagnosticLanguage, p
  * @param {import("../semantic/types.js").BackendLanguage} input.language - Registered program target.
  * @param {import("../semantic/types.js").SemanticProgram} input.program - Complete semantic program.
  * @param {"text" | "application"} [input.role] - Explicit artifact role; omitted preserves text generation.
- * @param {import("../semantic/types.js").IosApplicationConfigurationInput} [input.configuration] - iOS application configuration.
- * @param {import("../semantic/types.js").IosApplicationAssetInput[]} [input.assets] - Exact iOS caller assets.
+ * @param {import("../semantic/types.js").IosApplicationConfigurationInput | import("../semantic/types.js").AndroidApplicationConfigurationInput} [input.configuration] - Application configuration.
+ * @param {import("../semantic/types.js").IosApplicationAssetInput[] | import("../semantic/types.js").AndroidApplicationInputFile[]} [input.assets] - Exact caller assets.
+ * @param {import("../semantic/types.js").AndroidApplicationInputFile[]} [input.resources] - Exact Android caller resources.
  * @returns {import("../semantic/types.js").GeneratedArtifactSet} Transactionally validated artifact set.
  */
 export function generateProgramArtifacts(input) {

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)
   }
@@ -2255,6 +2255,12 @@ export function emitExpression(writer, expression, path, language, emitIdentifie
       emitExpression(writer, argument, `${path}/arguments/${index}`, language, emitIdentifier)
       if (dartMultiline) writer.synthetic(",\n", "Dart formatter argument separator", [expression], [path])
     })
+    const callArgumentSuffix = writer.callArgumentSuffixFor(expression)
+
+    if (callArgumentSuffix) {
+      writer.synthetic(`${expression.arguments.length ? ", " : ""}${callArgumentSuffix}`,
+        "target-container semantic call argument", [expression], [path])
+    }
     if (dartMultiline) writer.synthetic(dartIndent, "Dart call closing indentation", [expression], [path])
     writer.mapped(")", {mappingKind: "anchor", node: expression, path})
     return
@@ -2407,6 +2413,19 @@ export function emitExpression(writer, expression, path, language, emitIdentifie
     return
   }
 
+  if (language == "kotlin" && writer.usesMethodStringEquality() &&
+    (expression.operation == "StringEqual" || expression.operation == "StringNotEqual")) {
+    writer.mapped("(", {mappingKind: "anchor", node: expression, path})
+    if (expression.operation == "StringNotEqual") {
+      writer.mapped("!", {mappingKind: "exact", node: expression, path, role: "operator"})
+    }
+    emitExpression(writer, expression.left, `${path}/left`, language, emitIdentifier)
+    writer.mapped(".equals(", {mappingKind: "exact", node: expression, path, role: "operator"})
+    emitExpression(writer, expression.right, `${path}/right`, language, emitIdentifier)
+    writer.mapped("))", {mappingKind: "anchor", node: expression, path})
+    return
+  }
+
   if (language == "csharp" && ["IntegerAdd", "IntegerSubtract", "IntegerMultiply"].includes(expression.operation)) {
     writer.mapped("checked(", {mappingKind: "anchor", node: expression, path})
     emitExpression(writer, expression.left, `${path}/left`, language, emitIdentifier)

package/src/backends/writer.js

@@ -80,9 +80,13 @@ export class SourceWriter {
    * @param {string[]} [options.stdlibProviderImports] - Ordered provider names this module must import.
    * @param {string} [options.stdlibProviderOwnerModule] - Java owner module identity hosting the shared support block and shims.
    * @param {string[]} [options.stdlibProviderShims] - Java owner program-wide used operations exposed as public static shims.
+   * @param {(expression: import("../semantic/types.js").CallExpression) => string} [options.callNameResolver] - Target-container call spelling override.
+   * @param {string} [options.callArgumentSuffix] - Synthetic trailing argument for every semantic function call.
+   * @param {boolean} [options.methodStringEquality] - Emit string equality through the platform String method.
    */
-  constructor({filename, language, module, program, programPaths, sources, stdlibProviderEntries, stdlibProviderPath,
-    stdlibProviderPaths, stdlibProviderImports, stdlibProviderOwnerModule, stdlibProviderShims}) {
+  constructor({callArgumentSuffix, callNameResolver, filename, language, methodStringEquality, module, program, programPaths, sources,
+    stdlibProviderEntries, stdlibProviderPath, stdlibProviderPaths, stdlibProviderImports, stdlibProviderOwnerModule,
+    stdlibProviderShims}) {
     const index = createGenerationIndex(module, sources)
 
     this.filename = filename
@@ -90,6 +94,9 @@ export class SourceWriter {
     this.module = module
     this.program = program
     this.programPaths = programPaths
+    this.callArgumentSuffix = callArgumentSuffix
+    this.callNameResolver = callNameResolver
+    this.methodStringEquality = methodStringEquality ?? false
     this.index = index
     this.stdlibProviderEntries = stdlibProviderEntries
     this.stdlibProviderPath = stdlibProviderPath
@@ -386,6 +393,7 @@ export class SourceWriter {
    * @returns {string} Target call name.
    */
   callNameFor(expression) {
+    if (this.callNameResolver) return this.callNameResolver(expression)
     const declarationId = expression.resolution?.declarationId
     const owner = declarationId ? this.declarationModules.get(declarationId) : undefined
     const imported = declarationId ? this.#programModule()?.imports.find((item) => item.declarationId == declarationId) : undefined
@@ -398,6 +406,23 @@ export class SourceWriter {
     return declarationName(owner, declarationId)
   }
 
+  /**
+   * Returns a target-container trailing argument for a semantic call.
+   * @param {import("../semantic/types.js").CallExpression} _expression - Resolved semantic call.
+   * @returns {string | undefined} Synthetic argument spelling, when configured.
+   */
+  callArgumentSuffixFor(_expression) {
+    return this.callArgumentSuffix
+  }
+
+  /**
+   * Reports whether string equality must avoid a target runtime helper.
+   * @returns {boolean} Whether to emit the platform String method.
+   */
+  usesMethodStringEquality() {
+    return this.methodStringEquality
+  }
+
   /** Marks emission as occurring inside one top-level reference class. */
   beginReferenceClassEmission() {
     this.referenceClassEmissionDepth += 1

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())
+}