semantifold 0.5.0 → 0.6.0

package/build/src/backends/zig-runtime.d.ts

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

package/build/src/backends/zig-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zig-runtime.d.ts","sourceRoot":"","sources":["../../../src/backends/zig-runtime.js"],"names":[],"mappings":"AAEA,uGAAuG;AACvG,eAAO,MAAM,UAAU,g5EAmEtB,CAAA;AAED,wGAAwG;AACxG,eAAO,MAAM,QAAQ,0qBAmBpB,CAAA"}

package/build/src/backends/zig-runtime.js

@@ -0,0 +1,92 @@
+// @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);
+}
+`;
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/backends/zig-validation.d.ts

@@ -0,0 +1,9 @@
+/** Repository-owned bound for frozen CST traversal and deterministic project generation. */
+export declare const maximumZigSourceLength = 1000000;
+/**
+ * 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 declare function validateZigValues(module: import("../semantic/types.js").SemanticModule): void;
+//# sourceMappingURL=zig-validation.d.ts.map

package/build/src/backends/zig-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zig-validation.d.ts","sourceRoot":"","sources":["../../../src/backends/zig-validation.js"],"names":[],"mappings":"AAIA,4FAA4F;AAC5F,eAAO,MAAM,sBAAsB,UAAY,CAAA;AAE/C;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAH7B,OAAO,sBAAsB,EAAE,cAGF,GAF3B,IAAI,CAyDhB"}

package/build/src/backends/zig-validation.js

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

package/build/src/backends/zig.d.ts

@@ -0,0 +1,42 @@
+export type SemanticModule = import("../semantic/types.js").SemanticModule;
+export type SemanticNode = import("../semantic/types.js").SemanticNode;
+export type Expression = import("../semantic/types.js").Expression;
+export type Statement = import("../semantic/types.js").Statement;
+export type Scalar = import("../semantic/types.js").FunctionReturnTypeName;
+export type ZigPlannedValue = {
+    expression: Expression;
+    path: string;
+    type: Scalar;
+    name?: string;
+};
+export type ZigPlannedStep = {
+    result: ZigPlannedValue;
+    operands: ZigPlannedValue[];
+    rightSteps?: ZigPlannedStep[];
+};
+export type ZigStatementPlan = {
+    id: string;
+    steps: ZigPlannedStep[];
+    terminal?: ZigPlannedStep;
+    value?: ZigPlannedValue;
+};
+/**
+ * Produces a deterministic dependency-free Zig 0.15.2 native project after complete preflight.
+ * @param {{filename?: string, mapDirective?: unknown, module: SemanticModule, sourceMapFilename?: unknown, sources?: {filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]}} input - Artifact request.
+ * @returns {{artifacts: import("../semantic/types.js").GeneratedSetArtifact[], target: string}} Candidate project.
+ */
+export declare function generateZigProject({ filename, mapDirective, module, sourceMapFilename, sources }: {
+    filename?: string;
+    mapDirective?: unknown;
+    module: SemanticModule;
+    sourceMapFilename?: unknown;
+    sources?: {
+        filename: string;
+        content: string;
+        language?: import("../semantic/types.js").SemanticLanguage;
+    }[];
+}): {
+    artifacts: import("../semantic/types.js").GeneratedSetArtifact[];
+    target: string;
+};
+//# sourceMappingURL=zig.d.ts.map

package/build/src/backends/zig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zig.d.ts","sourceRoot":"","sources":["../../../src/backends/zig.js"],"names":[],"mappings":"AAcI,YAAyD,cAAc,GAA7D,OAAO,sBAAsB,EAAE,cAAc,CAAgB;AACvE,YAAuD,YAAY,GAAzD,OAAO,sBAAsB,EAAE,YAAY,CAAc;AACnE,YAAqD,UAAU,GAArD,OAAO,sBAAsB,EAAE,UAAU,CAAY;AAC/D,YAAoD,SAAS,GAAnD,OAAO,sBAAsB,EAAE,SAAS,CAAW;AAC7D,YAAiE,MAAM,GAA7D,OAAO,sBAAsB,EAAE,sBAAsB,CAAQ;AACvE,YAA+E,eAAe,GAApF;IAAC,UAAU,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAC,CAAiB;AAC9F,YAAiG,cAAc,GAArG;IAAC,MAAM,EAAE,eAAe,CAAC;IAAC,QAAQ,EAAE,eAAe,EAAE,CAAC;IAAC,UAAU,CAAC,EAAE,cAAc,EAAE,CAAA;CAAC,CAAgB;AAC/G,YAAqG,gBAAgB,GAA3G;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,cAAc,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,cAAc,CAAC;IAAC,KAAK,CAAC,EAAE,eAAe,CAAA;CAAC,CAAkB;AA6LzH;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,EAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAC,EAHpF;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,sBAAsB,EAAE,gBAAgB,CAAA;KAAC,EAAE,CAAA;CAGxH,GAFlF;IAAC,SAAS,EAAE,OAAO,sBAAsB,EAAE,oBAAoB,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CA4B9F"}