semantifold 0.1.1 → 0.3.0

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

@@ -0,0 +1,151 @@
+// @ts-check
+/** Canonical C17 support header; native ownership never enters semantic IR. */
+export const cRuntimeHeader = `#ifndef SEMANTIFOLD_RUNTIME_H
+#define SEMANTIFOLD_RUNTIME_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+_Static_assert(CHAR_BIT == 8, "Semantifold requires eight-bit bytes");
+_Static_assert(sizeof(int64_t) == 8, "Semantifold requires exact int64_t");
+_Static_assert(sizeof(size_t) == 8 && PTRDIFF_MAX == INT64_MAX, "Semantifold requires the qualified 64-bit ABI");
+
+typedef struct {
+    const unsigned char *data;
+    size_t length;
+} SemantifoldString;
+
+#define SEMANTIFOLD_STRING(literal) ((SemantifoldString){(const unsigned char *)(literal), sizeof(literal) - 1})
+
+typedef struct SemantifoldAllocation {
+    struct SemantifoldAllocation *next;
+    unsigned char data[];
+} SemantifoldAllocation;
+
+_Static_assert(sizeof(SemantifoldAllocation) == 8, "Semantifold requires the qualified arena metadata size");
+
+static SemantifoldAllocation *semantifold_arena = NULL;
+static size_t semantifold_arena_bytes = 0;
+
+static inline void semantifold_cleanup(void) {
+    while (semantifold_arena != NULL) {
+        SemantifoldAllocation *allocation = semantifold_arena;
+        semantifold_arena = allocation->next;
+        free(allocation);
+    }
+    semantifold_arena_bytes = 0;
+}
+
+_Noreturn static inline void semantifold_fatal(const char *message, size_t length) {
+    semantifold_cleanup();
+    (void)fwrite(message, 1, length, stderr);
+    exit(70);
+}
+
+static inline int64_t semantifold_integer_add(int64_t left, int64_t right) {
+    int64_t result;
+    if (__builtin_add_overflow(left, right, &result)) {
+        semantifold_fatal("semantifold: integer overflow\\n", sizeof("semantifold: integer overflow\\n") - 1);
+    }
+    return result;
+}
+
+static inline int64_t semantifold_integer_subtract(int64_t left, int64_t right) {
+    int64_t result;
+    if (__builtin_sub_overflow(left, right, &result)) {
+        semantifold_fatal("semantifold: integer overflow\\n", sizeof("semantifold: integer overflow\\n") - 1);
+    }
+    return result;
+}
+
+static inline int64_t semantifold_integer_multiply(int64_t left, int64_t right) {
+    int64_t result;
+    if (__builtin_mul_overflow(left, right, &result)) {
+        semantifold_fatal("semantifold: integer overflow\\n", sizeof("semantifold: integer overflow\\n") - 1);
+    }
+    return result;
+}
+
+static inline int64_t semantifold_integer_negate(int64_t value) {
+    return semantifold_integer_subtract(INT64_C(0), value);
+}
+
+static inline size_t semantifold_allocation_size(size_t left, size_t right) {
+    const size_t maximum = (size_t)PTRDIFF_MAX;
+    if (left > maximum || right > maximum - left ||
+        left + right > maximum - sizeof(SemantifoldAllocation)) {
+        semantifold_fatal("semantifold: allocation size\\n", sizeof("semantifold: allocation size\\n") - 1);
+    }
+    const size_t size = sizeof(SemantifoldAllocation) + left + right;
+    if (semantifold_arena_bytes > maximum - size) {
+        semantifold_fatal("semantifold: allocation size\\n", sizeof("semantifold: allocation size\\n") - 1);
+    }
+    return size;
+}
+
+static inline SemantifoldString semantifold_string_concat(SemantifoldString left, SemantifoldString right) {
+    const size_t size = semantifold_allocation_size(left.length, right.length);
+    SemantifoldAllocation *allocation = malloc(size);
+    if (allocation == NULL) {
+        semantifold_fatal("semantifold: allocation failure\\n", sizeof("semantifold: allocation failure\\n") - 1);
+    }
+    allocation->next = semantifold_arena;
+    semantifold_arena = allocation;
+    semantifold_arena_bytes += size;
+    if (left.length != 0) (void)memcpy(allocation->data, left.data, left.length);
+    if (right.length != 0) (void)memcpy(allocation->data + left.length, right.data, right.length);
+    return (SemantifoldString){allocation->data, left.length + right.length};
+}
+
+static inline bool semantifold_string_equal(SemantifoldString left, SemantifoldString right) {
+    return left.length == right.length && (left.length == 0 || memcmp(left.data, right.data, left.length) == 0);
+}
+
+static inline bool semantifold_string_not_equal(SemantifoldString left, SemantifoldString right) {
+    return !semantifold_string_equal(left, right);
+}
+
+static inline void semantifold_write(const unsigned char *data, size_t length) {
+    if (length != 0 && fwrite(data, 1, length, stdout) != length) {
+        semantifold_fatal("semantifold: output failure\\n", sizeof("semantifold: output failure\\n") - 1);
+    }
+}
+
+static inline void semantifold_newline(void) {
+    semantifold_write((const unsigned char *)"\\n", 1);
+    if (fflush(stdout) != 0) semantifold_fatal("semantifold: output failure\\n", sizeof("semantifold: output failure\\n") - 1);
+}
+
+static inline void semantifold_print_string(SemantifoldString value) {
+    semantifold_write(value.data, value.length);
+    semantifold_newline();
+}
+
+static inline void semantifold_print_boolean(bool value) {
+    if (value) semantifold_write((const unsigned char *)"true", 4);
+    else semantifold_write((const unsigned char *)"false", 5);
+    semantifold_newline();
+}
+
+static inline void semantifold_print_integer(int64_t value) {
+    unsigned char digits[20];
+    size_t position = sizeof(digits);
+    uint64_t magnitude = (uint64_t)value;
+    if (value < 0) magnitude = UINT64_C(0) - magnitude;
+    do {
+        digits[--position] = (unsigned char)(UINT64_C(48) + magnitude % UINT64_C(10));
+        magnitude /= UINT64_C(10);
+    } while (magnitude != 0);
+    if (value < 0) digits[--position] = (unsigned char)45;
+    semantifold_write(digits + position, sizeof(digits) - position);
+    semantifold_newline();
+}
+
+#endif
+`;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"c-runtime.js","sourceRoot":"","sources":["../../../src/backends/c-runtime.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,+EAA+E;AAC/E,MAAM,CAAC,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmJ7B,CAAA","sourcesContent":["// @ts-check\n\n/** Canonical C17 support header; native ownership never enters semantic IR. */\nexport const cRuntimeHeader = `#ifndef SEMANTIFOLD_RUNTIME_H\n#define SEMANTIFOLD_RUNTIME_H\n\n#include <stdbool.h>\n#include <stddef.h>\n#include <stdint.h>\n#include <limits.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\n_Static_assert(CHAR_BIT == 8, \"Semantifold requires eight-bit bytes\");\n_Static_assert(sizeof(int64_t) == 8, \"Semantifold requires exact int64_t\");\n_Static_assert(sizeof(size_t) == 8 && PTRDIFF_MAX == INT64_MAX, \"Semantifold requires the qualified 64-bit ABI\");\n\ntypedef struct {\n    const unsigned char *data;\n    size_t length;\n} SemantifoldString;\n\n#define SEMANTIFOLD_STRING(literal) ((SemantifoldString){(const unsigned char *)(literal), sizeof(literal) - 1})\n\ntypedef struct SemantifoldAllocation {\n    struct SemantifoldAllocation *next;\n    unsigned char data[];\n} SemantifoldAllocation;\n\n_Static_assert(sizeof(SemantifoldAllocation) == 8, \"Semantifold requires the qualified arena metadata size\");\n\nstatic SemantifoldAllocation *semantifold_arena = NULL;\nstatic size_t semantifold_arena_bytes = 0;\n\nstatic inline void semantifold_cleanup(void) {\n    while (semantifold_arena != NULL) {\n        SemantifoldAllocation *allocation = semantifold_arena;\n        semantifold_arena = allocation->next;\n        free(allocation);\n    }\n    semantifold_arena_bytes = 0;\n}\n\n_Noreturn static inline void semantifold_fatal(const char *message, size_t length) {\n    semantifold_cleanup();\n    (void)fwrite(message, 1, length, stderr);\n    exit(70);\n}\n\nstatic inline int64_t semantifold_integer_add(int64_t left, int64_t right) {\n    int64_t result;\n    if (__builtin_add_overflow(left, right, &result)) {\n        semantifold_fatal(\"semantifold: integer overflow\\\\n\", sizeof(\"semantifold: integer overflow\\\\n\") - 1);\n    }\n    return result;\n}\n\nstatic inline int64_t semantifold_integer_subtract(int64_t left, int64_t right) {\n    int64_t result;\n    if (__builtin_sub_overflow(left, right, &result)) {\n        semantifold_fatal(\"semantifold: integer overflow\\\\n\", sizeof(\"semantifold: integer overflow\\\\n\") - 1);\n    }\n    return result;\n}\n\nstatic inline int64_t semantifold_integer_multiply(int64_t left, int64_t right) {\n    int64_t result;\n    if (__builtin_mul_overflow(left, right, &result)) {\n        semantifold_fatal(\"semantifold: integer overflow\\\\n\", sizeof(\"semantifold: integer overflow\\\\n\") - 1);\n    }\n    return result;\n}\n\nstatic inline int64_t semantifold_integer_negate(int64_t value) {\n    return semantifold_integer_subtract(INT64_C(0), value);\n}\n\nstatic inline size_t semantifold_allocation_size(size_t left, size_t right) {\n    const size_t maximum = (size_t)PTRDIFF_MAX;\n    if (left > maximum || right > maximum - left ||\n        left + right > maximum - sizeof(SemantifoldAllocation)) {\n        semantifold_fatal(\"semantifold: allocation size\\\\n\", sizeof(\"semantifold: allocation size\\\\n\") - 1);\n    }\n    const size_t size = sizeof(SemantifoldAllocation) + left + right;\n    if (semantifold_arena_bytes > maximum - size) {\n        semantifold_fatal(\"semantifold: allocation size\\\\n\", sizeof(\"semantifold: allocation size\\\\n\") - 1);\n    }\n    return size;\n}\n\nstatic inline SemantifoldString semantifold_string_concat(SemantifoldString left, SemantifoldString right) {\n    const size_t size = semantifold_allocation_size(left.length, right.length);\n    SemantifoldAllocation *allocation = malloc(size);\n    if (allocation == NULL) {\n        semantifold_fatal(\"semantifold: allocation failure\\\\n\", sizeof(\"semantifold: allocation failure\\\\n\") - 1);\n    }\n    allocation->next = semantifold_arena;\n    semantifold_arena = allocation;\n    semantifold_arena_bytes += size;\n    if (left.length != 0) (void)memcpy(allocation->data, left.data, left.length);\n    if (right.length != 0) (void)memcpy(allocation->data + left.length, right.data, right.length);\n    return (SemantifoldString){allocation->data, left.length + right.length};\n}\n\nstatic inline bool semantifold_string_equal(SemantifoldString left, SemantifoldString right) {\n    return left.length == right.length && (left.length == 0 || memcmp(left.data, right.data, left.length) == 0);\n}\n\nstatic inline bool semantifold_string_not_equal(SemantifoldString left, SemantifoldString right) {\n    return !semantifold_string_equal(left, right);\n}\n\nstatic inline void semantifold_write(const unsigned char *data, size_t length) {\n    if (length != 0 && fwrite(data, 1, length, stdout) != length) {\n        semantifold_fatal(\"semantifold: output failure\\\\n\", sizeof(\"semantifold: output failure\\\\n\") - 1);\n    }\n}\n\nstatic inline void semantifold_newline(void) {\n    semantifold_write((const unsigned char *)\"\\\\n\", 1);\n    if (fflush(stdout) != 0) semantifold_fatal(\"semantifold: output failure\\\\n\", sizeof(\"semantifold: output failure\\\\n\") - 1);\n}\n\nstatic inline void semantifold_print_string(SemantifoldString value) {\n    semantifold_write(value.data, value.length);\n    semantifold_newline();\n}\n\nstatic inline void semantifold_print_boolean(bool value) {\n    if (value) semantifold_write((const unsigned char *)\"true\", 4);\n    else semantifold_write((const unsigned char *)\"false\", 5);\n    semantifold_newline();\n}\n\nstatic inline void semantifold_print_integer(int64_t value) {\n    unsigned char digits[20];\n    size_t position = sizeof(digits);\n    uint64_t magnitude = (uint64_t)value;\n    if (value < 0) magnitude = UINT64_C(0) - magnitude;\n    do {\n        digits[--position] = (unsigned char)(UINT64_C(48) + magnitude % UINT64_C(10));\n        magnitude /= UINT64_C(10);\n    } while (magnitude != 0);\n    if (value < 0) digits[--position] = (unsigned char)45;\n    semantifold_write(digits + position, sizeof(digits) - position);\n    semantifold_newline();\n}\n\n#endif\n`\n"]}

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

@@ -0,0 +1,12 @@
+export type SemanticModule = import("../semantic/types.js").SemanticModule;
+export type Expression = import("../semantic/types.js").Expression;
+export type SourceLocation = import("../semantic/types.js").SourceLocation;
+/** Maximum UTF-16 input accepted by the unchanged qualified legacy parser. */
+export declare const maximumCSourceLength = 32767;
+/**
+ * Rejects compile-time-known object and arena sizes; unknown runtime lengths remain checked in C.
+ * @param {SemanticModule} module - Shape/type-validated module.
+ * @returns {void}
+ */
+export declare function validateCMemory(module: SemanticModule): void;
+//# sourceMappingURL=c-validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"c-validation.d.ts","sourceRoot":"","sources":["../../../src/backends/c-validation.js"],"names":[],"mappings":"AAII,YAAyD,cAAc,GAA7D,OAAO,sBAAsB,EAAE,cAAc,CAAgB;AACvE,YAAqD,UAAU,GAArD,OAAO,sBAAsB,EAAE,UAAU,CAAY;AAC/D,YAAyD,cAAc,GAA7D,OAAO,sBAAsB,EAAE,cAAc,CAAgB;AAG3E,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,QAAQ,CAAA;AAEzC;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAH3B,cAG2B,GAFzB,IAAI,CAmEhB"}

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

@@ -0,0 +1,85 @@
+// @ts-check
+import { unsupportedCapability } from "../diagnostic.js";
+/** @typedef {import("../semantic/types.js").SemanticModule} SemanticModule */
+/** @typedef {import("../semantic/types.js").Expression} Expression */
+/** @typedef {import("../semantic/types.js").SourceLocation} SourceLocation */
+const maximumObjectBytes = 9223372036854775807n;
+/** Maximum UTF-16 input accepted by the unchanged qualified legacy parser. */
+export const maximumCSourceLength = 32767;
+const allocationMetadataBytes = 8n;
+/**
+ * Rejects compile-time-known object and arena sizes; unknown runtime lengths remain checked in C.
+ * @param {SemanticModule} module - Shape/type-validated module.
+ * @returns {void}
+ */
+export function validateCMemory(module) {
+    /**
+     * Checks one expression and its known byte lengths without folding the IR.
+     * @param {Expression} expression - Semantic expression.
+     * @param {Map<string, bigint | undefined>} lengths - Visible immutable or assigned lengths.
+     * @param {{bytes: bigint}} arena - Known minimum allocations in this lexical path.
+     * @returns {bigint | undefined} Known UTF-8 byte length.
+     */
+    function size(expression, lengths, arena) {
+        if (expression.kind == "StringLiteral") {
+            const bytes = BigInt(Buffer.byteLength(expression.value, "utf8"));
+            if (bytes > 4095n)
+                unsupportedCapability("c", "UTF-8 literal exceeds the strict C17 4095-byte translation limit", expression.location);
+            return bytes;
+        }
+        if (expression.kind == "IdentifierExpression")
+            return lengths.get(expression.name);
+        if (expression.kind == "CallExpression") {
+            for (const argument of expression.arguments)
+                size(argument, lengths, arena);
+        }
+        else if (expression.kind == "UnaryExpression")
+            size(expression.operand, lengths, arena);
+        else if (expression.kind == "BinaryExpression") {
+            const left = size(expression.left, lengths, arena);
+            const right = size(expression.right, lengths, arena);
+            if (expression.operation == "StringConcat") {
+                const minimum = (left ?? 0n) + (right ?? 0n);
+                arena.bytes += allocationMetadataBytes + minimum;
+                if (minimum > maximumObjectBytes - allocationMetadataBytes || arena.bytes > maximumObjectBytes) {
+                    unsupportedCapability("c", "known immutable slice or module arena size exceeds PTRDIFF_MAX", expression.location);
+                }
+                return left === undefined || right === undefined ? undefined : left + right;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Propagates known local descriptor sizes through straight-line code and both branch paths.
+     * @param {import("../semantic/types.js").Block} block - Semantic block.
+     * @param {Map<string, bigint | undefined>} inherited - Visible known lengths.
+     * @param {{bytes: bigint}} arena - Known path allocation size.
+     * @returns {Map<string, bigint | undefined>} Outgoing known lengths.
+     */
+    function visit(block, inherited, arena) {
+        const lengths = new Map(inherited);
+        for (const statement of block.statements) {
+            if (statement.kind == "LocalDeclaration")
+                lengths.set(statement.name, size(statement.initializer, lengths, arena));
+            else if (statement.kind == "AssignmentStatement")
+                lengths.set(statement.target.name, size(statement.expression, lengths, arena));
+            else if (statement.kind == "IfStatement") {
+                size(statement.condition, lengths, arena);
+                const leftArena = { bytes: arena.bytes };
+                const rightArena = { bytes: arena.bytes };
+                const left = visit(statement.consequent, lengths, leftArena);
+                const right = statement.alternate ? visit(statement.alternate, lengths, rightArena) : lengths;
+                for (const name of lengths.keys())
+                    lengths.set(name, left.get(name) === right.get(name) ? left.get(name) : undefined);
+                arena.bytes = leftArena.bytes < rightArena.bytes ? leftArena.bytes : rightArena.bytes;
+            }
+            else
+                size(statement.expression, lengths, arena);
+        }
+        return lengths;
+    }
+    for (const declaration of module.functions)
+        visit(declaration.body, new Map(), { bytes: 0n });
+    visit(module.entryPoint.body, new Map(), { bytes: 0n });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"c-validation.js","sourceRoot":"","sources":["../../../src/backends/c-validation.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {unsupportedCapability} from \"../diagnostic.js\"\n\n/** @typedef {import(\"../semantic/types.js\").SemanticModule} SemanticModule */\n/** @typedef {import(\"../semantic/types.js\").Expression} Expression */\n/** @typedef {import(\"../semantic/types.js\").SourceLocation} SourceLocation */\n\nconst maximumObjectBytes = 9223372036854775807n\n/** Maximum UTF-16 input accepted by the unchanged qualified legacy parser. */\nexport const maximumCSourceLength = 32767\nconst allocationMetadataBytes = 8n\n/**\n * Rejects compile-time-known object and arena sizes; unknown runtime lengths remain checked in C.\n * @param {SemanticModule} module - Shape/type-validated module.\n * @returns {void}\n */\nexport function validateCMemory(module) {\n  /**\n   * Checks one expression and its known byte lengths without folding the IR.\n   * @param {Expression} expression - Semantic expression.\n   * @param {Map<string, bigint | undefined>} lengths - Visible immutable or assigned lengths.\n   * @param {{bytes: bigint}} arena - Known minimum allocations in this lexical path.\n   * @returns {bigint | undefined} Known UTF-8 byte length.\n   */\n  function size(expression, lengths, arena) {\n    if (expression.kind == \"StringLiteral\") {\n      const bytes = BigInt(Buffer.byteLength(expression.value, \"utf8\"))\n\n      if (bytes > 4095n) unsupportedCapability(\"c\", \"UTF-8 literal exceeds the strict C17 4095-byte translation limit\", expression.location)\n      return bytes\n    }\n    if (expression.kind == \"IdentifierExpression\") return lengths.get(expression.name)\n    if (expression.kind == \"CallExpression\") {\n      for (const argument of expression.arguments) size(argument, lengths, arena)\n    } else if (expression.kind == \"UnaryExpression\") size(expression.operand, lengths, arena)\n    else if (expression.kind == \"BinaryExpression\") {\n      const left = size(expression.left, lengths, arena)\n      const right = size(expression.right, lengths, arena)\n\n      if (expression.operation == \"StringConcat\") {\n        const minimum = (left ?? 0n) + (right ?? 0n)\n\n        arena.bytes += allocationMetadataBytes + minimum\n        if (minimum > maximumObjectBytes - allocationMetadataBytes || arena.bytes > maximumObjectBytes) {\n          unsupportedCapability(\"c\", \"known immutable slice or module arena size exceeds PTRDIFF_MAX\", expression.location)\n        }\n        return left === undefined || right === undefined ? undefined : left + right\n      }\n    }\n    return undefined\n  }\n\n  /**\n   * Propagates known local descriptor sizes through straight-line code and both branch paths.\n   * @param {import(\"../semantic/types.js\").Block} block - Semantic block.\n   * @param {Map<string, bigint | undefined>} inherited - Visible known lengths.\n   * @param {{bytes: bigint}} arena - Known path allocation size.\n   * @returns {Map<string, bigint | undefined>} Outgoing known lengths.\n   */\n  function visit(block, inherited, arena) {\n    const lengths = new Map(inherited)\n\n    for (const statement of block.statements) {\n      if (statement.kind == \"LocalDeclaration\") lengths.set(statement.name, size(statement.initializer, lengths, arena))\n      else if (statement.kind == \"AssignmentStatement\") lengths.set(statement.target.name, size(statement.expression, lengths, arena))\n      else if (statement.kind == \"IfStatement\") {\n        size(statement.condition, lengths, arena)\n        const leftArena = {bytes: arena.bytes}\n        const rightArena = {bytes: arena.bytes}\n        const left = visit(statement.consequent, lengths, leftArena)\n        const right = statement.alternate ? visit(statement.alternate, lengths, rightArena) : lengths\n\n        for (const name of lengths.keys()) lengths.set(name, left.get(name) === right.get(name) ? left.get(name) : undefined)\n        arena.bytes = leftArena.bytes < rightArena.bytes ? leftArena.bytes : rightArena.bytes\n      } else size(statement.expression, lengths, arena)\n    }\n    return lengths\n  }\n\n  for (const declaration of module.functions) visit(declaration.body, new Map(), {bytes: 0n})\n  visit(module.entryPoint.body, new Map(), {bytes: 0n})\n}\n"]}

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

@@ -0,0 +1,31 @@
+export type SemanticModule = import("../semantic/types.js").SemanticModule;
+export type SemanticNode = import("../semantic/types.js").SemanticNode;
+export type Statement = import("../semantic/types.js").Statement;
+export type Block = import("../semantic/types.js").Block;
+export type PlannedValue = import("./ordered-expressions.js").PlannedValue;
+export type PlannedStep = import("./ordered-expressions.js").PlannedStep;
+export type StatementPlan = {
+    id: string;
+    steps: PlannedStep[];
+    value: PlannedValue;
+};
+/**
+ * Produces a fully validated, deterministic C17 translation unit and owned support header.
+ * @param {{filename?: string, mapDirective?: unknown, module: SemanticModule, sourceMapFilename?: unknown, sources?: {filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]}} input - Backend request.
+ * @returns {{artifacts: import("../semantic/types.js").GeneratedSetArtifact[], target: string}} Complete candidate.
+ */
+export declare function generateCProgram({ 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=c.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"c.d.ts","sourceRoot":"","sources":["../../../src/backends/c.js"],"names":[],"mappings":"AAYI,YAAyD,cAAc,GAA7D,OAAO,sBAAsB,EAAE,cAAc,CAAgB;AACvE,YAAuD,YAAY,GAAzD,OAAO,sBAAsB,EAAE,YAAY,CAAc;AACnE,YAAoD,SAAS,GAAnD,OAAO,sBAAsB,EAAE,SAAS,CAAW;AAC7D,YAAgD,KAAK,GAA3C,OAAO,sBAAsB,EAAE,KAAK,CAAO;AACrD,YAA2D,YAAY,GAA7D,OAAO,0BAA0B,EAAE,YAAY,CAAc;AACvE,YAA0D,WAAW,GAA3D,OAAO,0BAA0B,EAAE,WAAW,CAAa;AACrE,YAAmE,aAAa,GAAtE;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,WAAW,EAAE,CAAC;IAAC,KAAK,EAAE,YAAY,CAAA;CAAC,CAAe;AAWpF;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,EAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAC,EAHlF;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;CAG1H,GAFhF;IAAC,SAAS,EAAE,OAAO,sBAAsB,EAAE,oBAAoB,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CA+B9F"}