@kernlang/test 3.4.2 → 3.4.3-canary.9.1.62aecb74

package/dist/generated/safety-checks.d.ts

@@ -0,0 +1,2 @@
+export declare const BINDING_NAME_RE: RegExp;
+export declare function isRuntimeBindingName(value: string): boolean;

package/dist/generated/safety-checks.js

@@ -0,0 +1,7 @@
+// @kern-source: safety-checks:1
+export const BINDING_NAME_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+// @kern-source: safety-checks:3
+export function isRuntimeBindingName(value) {
+    return BINDING_NAME_RE.test(value);
+}
+//# sourceMappingURL=safety-checks.js.map

package/dist/generated/safety-checks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safety-checks.js","sourceRoot":"","sources":["../../src/generated/safety-checks.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,MAAM,CAAC,MAAM,eAAe,GAAW,4BAA4B,CAAC;AAEpE,gCAAgC;AAChC,MAAM,UAAU,oBAAoB,CAAC,KAAa;IAChD,OAAO,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACrC,CAAC"}

package/dist/index.js

@@ -1,9 +1,10 @@
-import { decompile, generateCoreNode, importTypeScript, parseDocumentWithDiagnostics, validateSchema, validateSemantics, } from '@kernlang/core';
+import { decompile, emitNativeKernBodyTS, generateCoreNode, importTypeScript, parseDocumentWithDiagnostics, validateSchema, validateSemantics, } from '@kernlang/core';
 import { execFileSync } from 'child_process';
 import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
 import { dirname, join, relative, resolve } from 'path';
 import { inspect, isDeepStrictEqual } from 'util';
 import { createContext, Script } from 'vm';
+import { isRuntimeBindingName } from './generated/safety-checks.js';
 const DISCOVERY_SKIP_DIRS = new Set([
     '.git',
     '.next',
@@ -426,6 +427,39 @@ function handlerText(node) {
         .filter(Boolean)
         .join('\n');
 }
+// `handlerText` returns the verbatim `props.code` from each handler child,
+// which is what most callers (reach analysis, length checks, regex sniffing)
+// want. The runtime-eval path is different: a handler with `lang="kern"`
+// stores raw KERN source in `props.code`, not JS. Feeding that to V8 yields
+// ReferenceErrors when tests reference symbols whose body is kern-native.
+// `runtimeHandlerSource` lowers each kern handler through the same emitter
+// the codegen path uses (`emitNativeKernBodyTS`), giving the runner a
+// JS body it can wrap and execute.
+//
+// On lowering failure we warn and inject a `throw new Error(...)` body so
+// the binding compiles cleanly but blows up at invocation with the actual
+// emitter error — instead of degrading to an empty body that surfaces as a
+// misleading downstream ReferenceError.
+function runtimeHandlerSource(node) {
+    return getChildren(node, 'handler')
+        .map((handler) => {
+        if (str(getProps(handler).lang) === 'kern') {
+            try {
+                return emitNativeKernBodyTS(handler);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const ownerName = str(getProps(node).name) || node.type;
+                console.warn(`[kern-test] kern handler lowering failed for '${ownerName}': ${message}`);
+                const literal = JSON.stringify(`kern handler lowering failed for '${ownerName}': ${message}`);
+                return `throw new Error(${literal});`;
+            }
+        }
+        return str(getProps(handler).code);
+    })
+        .filter(Boolean)
+        .join('\n');
+}
 function collectNamedHandlerBodies(root) {
     const bodies = new Map();
     for (const fn of collectNodes(root, 'fn')) {
@@ -2069,8 +2103,35 @@ function evaluateImportAssertion(node, context) {
     }
     return { passed: true };
 }
-const RUNTIME_EXPR_TIMEOUT_MS = 100;
-const RUNTIME_ASYNC_PROCESS_TIMEOUT_MS = 1500;
+function readPositiveIntEnv(name, fallback) {
+    const raw = process.env[name];
+    if (raw === undefined || raw === '')
+        return fallback;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return fallback;
+    return parsed;
+}
+// V8 enforces wall-clock time on `script.runInContext`. Under CPU contention
+// cold-compile + JIT can blow tight budgets — a 100ms default produced flaky
+// non-deterministic failures across runs. 1s is the new floor; override via
+// `KERN_TEST_RUNTIME_TIMEOUT_MS` for slow CI or expensive evals.
+const RUNTIME_EXPR_TIMEOUT_MS = readPositiveIntEnv('KERN_TEST_RUNTIME_TIMEOUT_MS', 1000);
+// Outer process timeout for the async eval path — must comfortably exceed
+// `RUNTIME_EXPR_TIMEOUT_MS` plus Node spawn cost (~200-400ms on busy machines).
+// We enforce a 2s safety margin even when the user overrides the env var: a
+// shorter outer timeout would kill the worker before V8 can report a real
+// inner timeout, surfacing as an opaque "process timed out" instead of the
+// actionable script-execution-timed-out error.
+const RUNTIME_ASYNC_PROCESS_FLOOR_MS = Math.max(5000, RUNTIME_EXPR_TIMEOUT_MS + 2000);
+const RUNTIME_ASYNC_PROCESS_TIMEOUT_MS = (() => {
+    const requested = readPositiveIntEnv('KERN_TEST_ASYNC_PROCESS_TIMEOUT_MS', RUNTIME_ASYNC_PROCESS_FLOOR_MS);
+    if (requested < RUNTIME_ASYNC_PROCESS_FLOOR_MS) {
+        console.warn(`[kern-test] KERN_TEST_ASYNC_PROCESS_TIMEOUT_MS=${requested} is below the required floor (${RUNTIME_ASYNC_PROCESS_FLOOR_MS}ms = max(5000, RUNTIME_EXPR_TIMEOUT_MS+2000)); using the floor instead.`);
+        return RUNTIME_ASYNC_PROCESS_FLOOR_MS;
+    }
+    return requested;
+})();
 const RUNTIME_EXPR_UNSAFE_TOKEN = /\b(?:async|class|constructor|Date|delete|do|eval|fetch|for|Function|global|globalThis|import|process|prototype|require|setInterval|setTimeout|switch|this|throw|try|while|with|WebSocket|XMLHttpRequest|__proto__)\b/;
 const RUNTIME_FN_UNSAFE_TOKEN = /\b(?:class|constructor|Date|delete|do|eval|fetch|Function|global|globalThis|import|process|prototype|require|setInterval|setTimeout|switch|this|with|WebSocket|XMLHttpRequest|__proto__)\b/;
 const RUNTIME_CLASS_UNSAFE_TOKEN = /\b(?:Date|delete|do|eval|fetch|Function|global|globalThis|import|process|prototype|require|setInterval|setTimeout|switch|with|WebSocket|XMLHttpRequest|__proto__)\b/;
@@ -2122,9 +2183,9 @@ function unsafeRuntimeWorkflowReason(source) {
         return `unsupported token '${unsafeToken}'`;
     return undefined;
 }
-function isRuntimeBindingName(value) {
-    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value);
-}
+// First slice of self-hosting: `isRuntimeBindingName` lives in
+// `src/kern/safety-checks.kern`. Edit the .kern file, then run
+// `pnpm --filter @kernlang/test kern:compile` to regenerate the facade.
 function transformRuntimeCodeSegments(source, transform) {
     let output = '';
     let segmentStart = 0;
@@ -2187,7 +2248,7 @@ function runtimeJsSource(source) {
         .replace(/\bfunction\s+([A-Za-z_$][\w$]*)\s*\(([^)]*)\)\s*:\s*[^{]+{/g, 'function $1($2) {'));
 }
 function runtimeConstHandlerExpr(node) {
-    const code = runtimeJsSource(handlerText(node).trim());
+    const code = runtimeJsSource(runtimeHandlerSource(node).trim());
     if (!code)
         return '';
     if (/^\s*(?:return|const|let|var|if|for|while|try|throw)\b/.test(code) || /;\s*$/.test(code)) {
@@ -2238,7 +2299,7 @@ function runtimeParamNames(node) {
     return parseLegacyParamNames(str(getProps(node).params));
 }
 function runtimeFunctionExpr(node) {
-    const code = runtimeJsSource(handlerText(node));
+    const code = runtimeJsSource(runtimeHandlerSource(node));
     if (!code)
         return '';
     const params = runtimeParamNames(node);
@@ -2249,7 +2310,7 @@ function runtimeFunctionExpr(node) {
 }
 function runtimeHandlerLines(node, spaces = 4) {
     const prefix = ' '.repeat(spaces);
-    const code = runtimeJsSource(handlerText(node).trim());
+    const code = runtimeJsSource(runtimeHandlerSource(node).trim());
     if (!code)
         return [];
     return code.split('\n').map((line) => `${prefix}${line}`);