semantifold 0.2.0 → 0.3.0

package/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semantifold",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Language-neutral semantic code analysis, transformation, generation, and execution toolkit",
   "type": "module",
   "main": "build/index.js",
@@ -20,14 +20,19 @@
     "src/**",
     "tsconfig.json"
   ],
+  "workspaces": [
+    "packages/tree-sitter-legacy"
+  ],
   "scripts": {
     "all-checks": "npm run lint && npm test",
-    "build": "node scripts/clean-build.js && tsc",
+    "build": "node scripts/clean-build.js && tsc && npm run build --workspace=semantifold-tree-sitter-legacy-workspace",
     "eslint": "eslint --max-warnings 0 .",
-    "lint": "npm run eslint && npm run typecheck",
-    "prepack": "npm run build",
+    "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",
     "test": "velocious-test spec",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit && npm run typecheck --workspace=semantifold-tree-sitter-legacy-workspace",
+    "verify:legacy-runtime": "node scripts/verify-legacy-runtime.js"
   },
   "engines": {
     "node": ">=24"
@@ -52,9 +57,19 @@
     "@ruby/prism": "^1.9.0",
     "comment-parser": "^1.4.1",
     "php-parser": "^3.7.0",
+    "semantifold-tree-sitter-legacy-internal": "file:packages/tree-sitter-legacy/runtime",
     "tree-sitter": "0.25.1",
+    "tree-sitter-c-sharp": "0.23.5",
+    "tree-sitter-go": "0.25.0",
     "tree-sitter-python": "0.25.0"
   },
+  "bundleDependencies": [
+    "semantifold-tree-sitter-legacy-internal",
+    "tree-sitter"
+  ],
+  "acceptDependencies": {
+    "semantifold-tree-sitter-legacy-internal": "0.1.0"
+  },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/node": "^24.3.0",
@@ -65,6 +80,7 @@
     "eslint-plugin-jsdoc-inline-type-casts": "https://github.com/kaspernj/eslint-plugin-jsdoc-inline-type-casts/archive/441b6c5ca335a115a75d9f050134357ddb0a61d1.tar.gz",
     "eslint-plugin-jsdoc-tag-lines": "^1.0.1",
     "globals": "^17.0.0",
+    "semantifold-tree-sitter-legacy-workspace": "0.1.0",
     "typescript": "^7.0.0",
     "yaml": "^2.9.0"
   }

package/src/acceptance.js

@@ -14,7 +14,7 @@ const acceptanceMaxBuffer = 16 * 1024 * 1024
 const launchErrorCodes = new Set([
   "E2BIG", "EACCES", "EAGAIN", "ELOOP", "EMFILE", "ENAMETOOLONG", "ENFILE", "ENOENT", "ENOEXEC", "ENOMEM", "ENOTDIR", "ENOTSUP", "EPERM", "ETXTBSY"
 ])
-const orderedStages = Object.freeze(["parse", "generate", "compile", "link", "validate", "instantiate", "execute"])
+const orderedStages = Object.freeze(["parse", "generate", "restore", "compile", "link", "validate", "instantiate", "execute"])
 const stageIndexes = new Map(orderedStages.map((stage, index) => [stage, index]))
 
 /**
@@ -28,6 +28,26 @@ const stageIndexes = new Map(orderedStages.map((stage, index) => [stage, index])
  * @returns {Promise<import("./semantic/types.js").AcceptanceResult>} Captured results after cleanup.
  */
 export async function runAcceptanceStages(input) {
+  return await runAcceptanceStagesWithDependencies(input, rm)
+}
+
+/**
+ * Creates an acceptance runner with instance-owned cleanup behavior.
+ * @param {object} dependencies - Internal runner dependencies.
+ * @param {typeof rm} dependencies.removeDirectory - Isolated-directory removal operation.
+ * @returns {typeof runAcceptanceStages} Acceptance runner.
+ */
+export function createAcceptanceRunner({removeDirectory}) {
+  return async (input) => await runAcceptanceStagesWithDependencies(input, removeDirectory)
+}
+
+/**
+ * Runs acceptance with exact instance-owned dependencies.
+ * @param {Parameters<typeof runAcceptanceStages>[0]} input - Acceptance request.
+ * @param {typeof rm} removeDirectory - Isolated-directory removal operation.
+ * @returns {ReturnType<typeof runAcceptanceStages>} Captured results after cleanup.
+ */
+async function runAcceptanceStagesWithDependencies(input, removeDirectory) {
   if (!isPlainObject(input)) invalidRunner("Acceptance requires a request object.", "acceptance")
   const artifacts = /** @type {import("./semantic/types.js").GeneratedArtifactSet} */ (input.artifacts)
   const environment = /** @type {Readonly<Record<string, string | undefined>>} */ (
@@ -84,7 +104,7 @@ export async function runAcceptanceStages(input) {
   let cleanupFailed = false
 
   try {
-    await removeAcceptanceDirectory(directory, request.target)
+    await removeAcceptanceDirectory(directory, request.target, removeDirectory)
   } catch (error) {
     cleanupFailed = true
     cleanupFailure = error
@@ -300,11 +320,12 @@ function isPlainObject(value) {
  * Removes the isolated acceptance directory with a normalized failure.
  * @param {string} directory - Exact temporary directory.
  * @param {string} target - Acceptance target.
+ * @param {typeof rm} removeDirectory - Instance-owned removal operation.
  * @returns {Promise<void>} Cleanup completion.
  */
-async function removeAcceptanceDirectory(directory, target) {
+async function removeAcceptanceDirectory(directory, target, removeDirectory) {
   try {
-    await rm(directory, {force: true, recursive: true})
+    await removeDirectory(directory, {force: true, recursive: true})
   } catch (error) {
     throw new SemantifoldDiagnostic({
       cause: error instanceof Error ? error : undefined,

package/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
+`

package/src/backends/c-validation.js

@@ -0,0 +1,83 @@
+// @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})
+}