@scriptc/compiler 0.1.4 → 0.1.6

package/ambient/scriptc-node-fallback.d.ts

@@ -2228,6 +2228,7 @@ declare module "net" {
     once(event: "session", listener: (session: Buffer) => void): void;
   }
   export interface Server {
+    readonly listening: boolean;
     /* Node answers the server itself (`return this` chaining). */
     listen(port: number, callback?: () => void): Server;
     /* The positional bind address (the options form's host in argument
@@ -2246,6 +2247,7 @@ declare module "net" {
     emit(event: "connection", socket: Socket): boolean;
     on(event: "connection" | "secureConnection", listener: (socket: Socket) => void): void;
     on(event: "close" | "listening", listener: () => void): void;
+    on(event: "timeout", listener: (socket: Socket) => void): void;
     on(event: "error", listener: (err: Error) => void): void;
     /* The WebSocket handover: fires INSTEAD of 'request' for
      * Connection: upgrade requests, with the raw socket + head bytes. */
@@ -2256,11 +2258,13 @@ declare module "net" {
     /* addListener IS on (Node aliases them) — the suite spells both. */
     addListener(event: "connection" | "secureConnection", listener: (socket: Socket) => void): void;
     addListener(event: "close" | "listening", listener: () => void): void;
+    addListener(event: "timeout", listener: (socket: Socket) => void): void;
     addListener(event: "error", listener: (err: Error) => void): void;
     addListener(event: "upgrade", listener: (req: import("http").IncomingMessage, socket: Socket, head: Buffer) => void): void;
     addListener(event: "request", listener: (req: import("http").IncomingMessage, res: import("http").ServerResponse) => void): void;
     once(event: "connection" | "secureConnection", listener: (socket: Socket) => void): void;
     once(event: "close" | "listening", listener: () => void): void;
+    once(event: "timeout", listener: (socket: Socket) => void): void;
     once(event: "error", listener: (err: Error) => void): void;
     once(event: "upgrade", listener: (req: import("http").IncomingMessage, socket: Socket, head: Buffer) => void): void;
     once(event: "request", listener: (req: import("http").IncomingMessage, res: import("http").ServerResponse) => void): void;
@@ -2317,8 +2321,14 @@ declare module "node:net" {
  * connection per call (no agent pooling) with Node's exact wire head. */
 declare module "http" {
   import { Server as NetServer, Socket } from "net";
+  export const METHODS: string[];
+  export const STATUS_CODES: { [status: number]: string | undefined };
+  export const maxHeaderSize: number;
   export interface Server extends NetServer {
     timeout: number;
+    setTimeout(msecs: number, callback?: (socket: Socket) => void): this;
+    closeAllConnections(): void;
+    closeIdleConnections(): void;
     keepAliveTimeout: number;
     keepAliveTimeoutBuffer: number;
     headersTimeout: number;
@@ -2356,9 +2366,13 @@ declare module "http" {
   export interface IncomingMessage {
     readonly url: string;
     readonly method: string;
+    readonly httpVersion: string;
+    readonly complete: boolean;
+    readonly aborted: boolean;
     readonly statusCode: number | undefined;
     readonly statusMessage: string | undefined;
     readonly socket: Socket;
+    readonly connection: Socket;
     readonly headers: { [name: string]: string | undefined };
     readonly headersDistinct: { [name: string]: string[] | undefined };
     readonly rawHeaders: string[];
@@ -2367,51 +2381,67 @@ declare module "http" {
     readonly rawTrailers: string[];
     resume(): void;
     destroy(): void;
+    setTimeout(msecs: number, callback?: () => void): this;
     /* setEncoding('utf8'): 'data' delivers strings (other real encodings
      * fence loudly at runtime; unknown names throw ERR_UNKNOWN_ENCODING). */
     setEncoding(encoding: string): void;
     /* The proxy legs: the body streams into a ServerResponse, a
      * ClientRequest, or a raw Socket; natural end ends the destination. */
-    pipe(destination: ServerResponse | ClientRequest | Socket): void;
+    pipe(destination: ServerResponse | import("http2").Http2ServerResponse | ClientRequest | Socket): void;
     on(event: "data", listener: (chunk: any) => void): void;
-    on(event: "end" | "close", listener: () => void): void;
+    on(event: "end" | "close" | "aborted", listener: () => void): void;
     on(event: "error", listener: (err: Error) => void): void;
     /* addListener IS on (Node aliases them) — the suite spells both. */
     addListener(event: "data", listener: (chunk: any) => void): void;
-    addListener(event: "end" | "close", listener: () => void): void;
+    addListener(event: "end" | "close" | "aborted", listener: () => void): void;
     addListener(event: "error", listener: (err: Error) => void): void;
     once(event: "data", listener: (chunk: any) => void): void;
-    once(event: "end" | "close", listener: () => void): void;
+    once(event: "end" | "close" | "aborted", listener: () => void): void;
     once(event: "error", listener: (err: Error) => void): void;
   }
   export interface ServerResponse {
     readonly headersSent: boolean;
+    readonly writableEnded: boolean;
+    readonly finished: boolean;
+    readonly writableFinished: boolean;
     readonly writableCorked: number;
+    readonly req: IncomingMessage;
+    readonly socket: Socket | null;
+    readonly connection: Socket | null;
+    sendDate: boolean;
+    strictContentLength: boolean;
     /* Node's writable head properties: the implicit head reads them. */
     statusCode: number;
-    statusMessage: string;
+    statusMessage: string | undefined;
     setHeader(name: string, value: string | number): void;
     getHeader(name: string): string | undefined;
+    getHeaderNames(): string[];
+    getRawHeaderNames(): string[];
+    getHeaders(): OutgoingHttpHeaders;
     hasHeader(name: string): boolean;
     removeHeader(name: string): void;
     /* Both overloads answer the response (`return this` chaining); the
      * headers argument also takes Node's flat [name, value, ...] array. */
     writeHead(statusCode: number, headers?: OutgoingHttpHeaders | string[]): ServerResponse;
     writeHead(statusCode: number, statusMessage: string, headers?: OutgoingHttpHeaders | string[]): ServerResponse;
+    writeContinue(callback?: () => void): void;
+    writeProcessing(callback?: () => void): void;
+    writeEarlyHints(hints: Record<string, string | string[]>, callback?: () => void): void;
     write(data: string | Uint8Array): void;
     flushHeaders(): void;
     cork(): void;
     uncork(): void;
     addTrailers(headers: OutgoingHttpHeaders | ReadonlyArray<[string, string]>): void;
+    setTimeout(msecs: number, callback?: () => void): this;
     /* end's callback forms fire once the body went out (the 'finish'
      * emit, deferred past the handler's synchronous tail). */
     end(data?: string | Uint8Array, callback?: () => void): void;
     end(callback: () => void): void;
     destroy(): void;
-    on(event: "close", listener: () => void): void;
+    on(event: "close" | "finish", listener: () => void): void;
     /* addListener IS on (Node aliases them) — the suite spells both. */
-    addListener(event: "close", listener: () => void): void;
-    once(event: "close", listener: () => void): void;
+    addListener(event: "close" | "finish", listener: () => void): void;
+    once(event: "close" | "finish", listener: () => void): void;
   }
   /* The CLIENT slice (http.request/http.get): the options-object form
    * with hostname/host, port, path, method, timeout, and headers; the
@@ -2478,26 +2508,52 @@ declare module "http" {
   export const globalAgent: Agent;
   export interface ClientRequest {
     readonly destroyed: boolean;
+    readonly aborted: boolean;
+    readonly socket: Socket;
+    readonly connection: Socket;
     readonly writableCorked: number;
+    readonly method: string;
+    readonly path: string;
+    readonly host: string;
+    readonly protocol: string;
+    readonly headersSent: boolean;
+    readonly writableEnded: boolean;
+    readonly writableFinished: boolean;
+    readonly finished: boolean;
+    readonly reusedSocket: boolean;
+    setHeader(name: string, value: string): void;
+    getHeader(name: string): string | undefined;
+    hasHeader(name: string): boolean;
+    removeHeader(name: string): void;
+    getHeaderNames(): string[];
+    getRawHeaderNames(): string[];
+    getHeaders(): OutgoingHttpHeaders;
     flushHeaders(): void;
     addTrailers(headers: OutgoingHttpHeaders | ReadonlyArray<[string, string]>): void;
     cork(): void;
     uncork(): void;
+    setNoDelay(noDelay?: boolean): void;
+    setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
+    setTimeout(timeout: number, callback?: () => void): this;
     write(data: string | Uint8Array): void;
     end(data?: string | Uint8Array): void;
     destroy(): void;
+    abort(): void;
     on(event: "response", listener: (res: IncomingMessage) => void): void;
+    on(event: "socket", listener: (socket: Socket) => void): void;
     on(event: "upgrade", listener: (res: IncomingMessage, socket: Socket, head: Buffer) => void): void;
-    on(event: "timeout" | "close", listener: () => void): void;
+    on(event: "timeout" | "close" | "finish" | "abort", listener: () => void): void;
     on(event: "error", listener: (err: Error) => void): void;
     /* addListener IS on (Node aliases them) — the suite spells both. */
     addListener(event: "response", listener: (res: IncomingMessage) => void): void;
+    addListener(event: "socket", listener: (socket: Socket) => void): void;
     addListener(event: "upgrade", listener: (res: IncomingMessage, socket: Socket, head: Buffer) => void): void;
-    addListener(event: "timeout" | "close", listener: () => void): void;
+    addListener(event: "timeout" | "close" | "finish" | "abort", listener: () => void): void;
     addListener(event: "error", listener: (err: Error) => void): void;
     once(event: "response", listener: (res: IncomingMessage) => void): void;
+    once(event: "socket", listener: (socket: Socket) => void): void;
     once(event: "upgrade", listener: (res: IncomingMessage, socket: Socket, head: Buffer) => void): void;
-    once(event: "timeout" | "close", listener: () => void): void;
+    once(event: "timeout" | "close" | "finish" | "abort", listener: () => void): void;
     once(event: "error", listener: (err: Error) => void): void;
   }
   export function createServer(
@@ -2528,6 +2584,8 @@ declare module "http" {
     target: RequestOptions | string | URL,
     callback?: (res: IncomingMessage) => void,
   ): ClientRequest;
+  export function validateHeaderName(name: string, label?: string): void;
+  export function validateHeaderValue(name: string, value: unknown): void;
 }
 declare module "node:http" {
   export * from "http";
@@ -2700,6 +2758,7 @@ declare module "http2" {
   }
   export interface Http2ServerResponse {
     readonly headersSent: boolean;
+    readonly writableEnded: boolean;
     readonly writableCorked: number;
     /* The same lowered surface as http.ServerResponse — the allowHTTP1
      * lowering serves every connection as HTTP/1.1, where the compat
@@ -2708,10 +2767,15 @@ declare module "http2" {
     statusMessage: string;
     setHeader(name: string, value: string | number): void;
     getHeader(name: string): string | undefined;
+    getHeaderNames(): string[];
+    getRawHeaderNames(): string[];
+    getHeaders(): import("http").OutgoingHttpHeaders;
     hasHeader(name: string): boolean;
     removeHeader(name: string): void;
     writeHead(statusCode: number, headers?: import("http").OutgoingHttpHeaders | string[]): Http2ServerResponse;
     writeHead(statusCode: number, statusMessage: string, headers?: import("http").OutgoingHttpHeaders | string[]): Http2ServerResponse;
+    writeContinue(): void;
+    writeEarlyHints(hints: Record<string, string | string[]>): void;
     write(data: string | Uint8Array): void;
     flushHeaders(): void;
     cork(): void;

package/dist/backend/c/c-emitter.d.ts

@@ -1,4 +1,6 @@
 import type { IrBytesElem, IrGlobal, IrRecordShape, IrExpr, IrFfiImport, IrFunction, IrLocal, IrModule, IrStmt, IrType, IrUnionDef, SrcLoc } from "../../ir/ir.js";
+import type { IntegerRanges } from "../../ir/integer-ranges.js";
+import { type ConstantNumericTable } from "../../ir/constant-tables.js";
 import { type FfiCallbackAdapter } from "../ffi-callbacks.js";
 import { VtSlot, ClassMeta } from "./shapes.js";
 import { type StreamTypedRefAdapter } from "./exprs.js";
@@ -30,7 +32,7 @@ export declare class CEmitter {
     /** Kind-specialized typed-array access helpers actually used by this
      * program. Keeping these in the generated TU means unrelated binaries do
      * not pay even debug/link metadata for byte-loop fast paths. */
-    readonly bytesElementHelpers: Set<"get:f32:f64" | "get:f32:u64" | "get:i32:f64" | "get:i32:u64" | "get:u32:f64" | "get:u32:u64" | "get:u8:f64" | "get:u8:u64" | "set:f32:f64" | "set:f32:u64" | "set:i32:f64" | "set:i32:u64" | "set:u32:f64" | "set:u32:u64" | "set:u8:f64" | "set:u8:u64">;
+    readonly bytesElementHelpers: Set<"get:f32:f64" | "get:f32:u64" | "get:f64:f64" | "get:f64:u64" | "get:i32:f64" | "get:i32:u64" | "get:u32:f64" | "get:u32:u64" | "get:u8:f64" | "get:u8:u64" | "set:f32:f64" | "set:f32:u64" | "set:f64:f64" | "set:f64:u64" | "set:i32:f64" | "set:i32:u64" | "set:u32:f64" | "set:u32:u64" | "set:u8:f64" | "set:u8:u64">;
     /** Interned unit-armed union instances: "unionId:tag" → static symbol.
      * A unit arm (undefined/null) has no payload, so every instance of one
      * (union, tag) pair is identical — ONE immortal (rc == SIZE_MAX) static
@@ -72,6 +74,7 @@ export declare class CEmitter {
      * unsigned integer shadow. Ordinary number reads widen the shadow back to
      * f64; direct byte indices consume it without a conversion round trip. */
     integerLoopBindings: Map<string, string>;
+    integerRanges: IntegerRanges;
     /** Declared functions referenced as values: each needs an env-signature
      * wrapper + an interned immortal closure (so `f === f` holds). */
     readonly fnValues: Set<string>;
@@ -138,6 +141,7 @@ export declare class CEmitter {
     readonly ffiHasRetainedCallback: boolean;
     readonly ffiHasForeignCallback: boolean;
     readonly globalsById: Map<string, IrGlobal>;
+    readonly constantNumericTables: ReadonlyMap<string, ConstantNumericTable>;
     readonly unionsById: Map<string, IrUnionDef>;
     /** Active optional-chain bind temps, by chain id (chainRecv reads). */
     readonly chainTemps: Map<string, Temp>;

package/dist/backend/c/c-emitter.js

@@ -1,9 +1,11 @@
 import { InternalCompilerError } from "../../errors.js";
 import { ffiCallbackType, funcOf, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isRefCounted, isUnitType, mapOf, moduleEmbedsCompressedNpm, moduleUsesChildProcess, moduleUsesDgram, moduleUsesDynInvoke, moduleEmbedsBuiltin, moduleUsesFetch, moduleUsesFsWatch, moduleUsesHttp2, moduleUsesHttpServer, moduleUsesNet, moduleUsesNodeTest, moduleUsesProcessEvents, moduleUsesStream, moduleUsesTls, moduleUsesTlsCa, POINTER_KINDS, RUNTIME_EMITTER_CLASS, STRING, VOID } from "../../ir/ir.js";
 import { undefinedArmTag } from "../../ir/analysis.js";
+import { scalarizeNumericRecords } from "../../ir/scalar-records.js";
+import { findConstantNumericTables } from "../../ir/constant-tables.js";
 import { allocateFfiCallbackAdapters, hasForeignFfiCallback, hasRetainedFfiCallback } from "../ffi-callbacks.js";
 import { mangleAsyncSpawn, mangleGenSpawn, mangleClassObj, mangleField, mangleGlobal, mangleFnClosure, mangleFunction, mangleLocal, mangleRawParam, mangleVtSlot, mangleWrapper, } from "../mangle.js";
-import { cCommentText, cFnPtrCast, cType, releaseCallC, cStringLiteral, cDecl } from "./types.js";
+import { cCommentText, cFnPtrCast, cType, releaseCallC, cStringLiteral, cDecl, cNumberLiteral } from "./types.js";
 import { computeMayThrow } from "./may-throw.js";
 import { unionTruthyHelper, unionEqHelper, unionToStrHelper, unionJoinHelper, jsonWriteHelper, jsonIndentHelper, dynMatchHelper, dynCheckHelper, dynFuncBoxHelper, dynToStrHelper, caughtToDynHelper, toDynHelper, recordKeyGetHelper, recordKeySetHelper } from "./walkers.js";
 import { emitStructDefs, vtEntriesFor, vtSlotParams, emitVtableDecls, emitVtableInstances, emitVtAdapterDefs, emitHierarchyClassHelpers, emitClassObjs, emitCtorThunkDefs, errorVtStampLines, emitterVtStampLines, streamVtStampLines, traceAdapterC, traceArgC, boxNewC, arrNewC } from "./shapes.js";
@@ -13,7 +15,7 @@ import { emitFunction, emitBlock, emitStmts, emitStmt, emitTryCatch, emitSwitch,
 import { emitExpr, liveDynRefAdapter as buildLiveDynRefAdapter } from "./exprs.js";
 import { emitLibraryIdentityLines } from "../library-identity-markers.js";
 export function emitCModule(mod, sourceText, options = {}) {
-    return new CEmitter(mod, sourceText, options).emit();
+    return new CEmitter(scalarizeNumericRecords(mod), sourceText, options).emit();
 }
 function ffiNativeTypeC(cls) {
     switch (cls) {
@@ -106,6 +108,7 @@ export class CEmitter {
      * unsigned integer shadow. Ordinary number reads widen the shadow back to
      * f64; direct byte indices consume it without a conversion round trip. */
     integerLoopBindings = new Map();
+    integerRanges = new Map();
     /** Declared functions referenced as values: each needs an env-signature
      * wrapper + an interned immortal closure (so `f === f` holds). */
     fnValues = new Set();
@@ -172,6 +175,7 @@ export class CEmitter {
     ffiHasRetainedCallback;
     ffiHasForeignCallback;
     globalsById = new Map();
+    constantNumericTables;
     unionsById = new Map();
     /** Active optional-chain bind temps, by chain id (chainRecv reads). */
     chainTemps = new Map();
@@ -319,6 +323,7 @@ export class CEmitter {
     constructor(mod, sourceText, options = {}) {
         this.mod = mod;
         this.options = options;
+        this.constantNumericTables = findConstantNumericTables(mod);
         this.ffiCallbackAdapters = allocateFfiCallbackAdapters(mod.ffiImports ?? []);
         this.ffiHasRetainedCallback = hasRetainedFfiCallback(mod.ffiImports ?? []);
         this.ffiHasForeignCallback = hasForeignFfiCallback(mod.ffiImports ?? []);
@@ -578,6 +583,12 @@ export class CEmitter {
             ``,
         ];
         out.push(...this.emitBytesElementHelpers());
+        for (const table of this.constantNumericTables.values()) {
+            out.push(`static const double ${table.symbol}[] = { ${table.values.map(cNumberLiteral).join(", ")} };`, `static inline double ${table.symbol}_get(const ScrArr *a, double i) {`, 
+            // Range checks precede the conversion: NaN, infinities and large
+            // numbers must never reach a C float-to-integer conversion.
+            `  if (a != NULL && i >= 0.0 && i < ${table.values.length}.0) {`, `    size_t index = (size_t)i;`, `    if ((double)index == i) return ${table.symbol}[index];`, `  }`, `  return scr_arr_get_number(a, i);`, `}`, ``);
+        }
         // Struct defs render into their own buffer BEFORE the unit-instance
         // table flushes: class newFns point undefined-armed union fields at
         // interned unit instances (fields start as JS's undefined, not NULL),
@@ -1273,10 +1284,10 @@ export class CEmitter {
         if (hasU64) {
             out.push(`static inline size_t sc_bytes_index_u64_checked(const ScrBytes *b, uint64_t i) {`, `  if (i >= b->len) { (void)scr_bytes_get(b, (double)i); return 0; }`, `  return (size_t)i;`, `}`);
         }
-        if ([...this.bytesElementHelpers].some((key) => key.startsWith("set:") && key.split(":")[1] !== "f32")) {
+        if ([...this.bytesElementHelpers].some((key) => key.startsWith("set:") && !key.startsWith("set:f32:") && !key.startsWith("set:f64:"))) {
             out.push(`static inline uint32_t sc_bytes_coerce_u32(double v) {`, `  if (v >= -9007199254740992.0 && v <= 9007199254740992.0) return (uint32_t)(int64_t)v;`, `  if (v != v || isinf(v)) return 0;`, `  double t = fmod(trunc(v), 4294967296.0);`, `  if (t < 0) t += 4294967296.0;`, `  return (uint32_t)t;`, `}`);
         }
-        for (const elem of ["u8", "u32", "i32", "f32"]) {
+        for (const elem of ["u8", "u32", "i32", "f32", "f64"]) {
             for (const mode of ["f64", "u64"]) {
                 const suffix = mode === "u64" ? "_u64" : "";
                 const indexType = mode === "u64" ? "uint64_t" : "double";
@@ -1286,8 +1297,9 @@ export class CEmitter {
                         out.push(`static inline double sc_bytes_get_u8${suffix}(const ScrBytes *b, ${indexType} i) {`, `  return (double)b->data[${checked}(b, i)];`, `}`);
                     }
                     else {
-                        const valueType = elem === "f32" ? "float" : elem === "i32" ? "int32_t" : "uint32_t";
-                        out.push(`static inline double sc_bytes_get_${elem}${suffix}(const ScrBytes *b, ${indexType} i) {`, `  ${valueType} v;`, `  memcpy(&v, b->data + ${checked}(b, i) * 4, 4);`, `  return (double)v;`, `}`);
+                        const valueType = elem === "f32" ? "float" : elem === "f64" ? "double" : elem === "i32" ? "int32_t" : "uint32_t";
+                        const size = elem === "f64" ? 8 : 4;
+                        out.push(`static inline double sc_bytes_get_${elem}${suffix}(const ScrBytes *b, ${indexType} i) {`, `  ${valueType} v;`, `  memcpy(&v, b->data + ${checked}(b, i) * ${size}, ${size});`, `  return (double)v;`, `}`);
                     }
                 }
                 if (this.bytesElementHelpers.has(`set:${elem}:${mode}`)) {
@@ -1295,9 +1307,10 @@ export class CEmitter {
                         out.push(`static inline void sc_bytes_set_u8${suffix}(ScrBytes *b, ${indexType} i, double v) {`, `  b->data[${checked}(b, i)] = (uint8_t)sc_bytes_coerce_u32(v);`, `}`);
                     }
                     else {
-                        const valueType = elem === "f32" ? "float" : "uint32_t";
-                        const init = elem === "f32" ? `(float)v` : `sc_bytes_coerce_u32(v)`;
-                        out.push(`static inline void sc_bytes_set_${elem}${suffix}(ScrBytes *b, ${indexType} i, double v) {`, `  size_t idx = ${checked}(b, i);`, `  ${valueType} stored = ${init};`, `  memcpy(b->data + idx * 4, &stored, 4);`, `}`);
+                        const valueType = elem === "f32" ? "float" : elem === "f64" ? "double" : "uint32_t";
+                        const init = elem === "f32" ? `(float)v` : elem === "f64" ? "v" : `sc_bytes_coerce_u32(v)`;
+                        const size = elem === "f64" ? 8 : 4;
+                        out.push(`static inline void sc_bytes_set_${elem}${suffix}(ScrBytes *b, ${indexType} i, double v) {`, `  size_t idx = ${checked}(b, i);`, `  ${valueType} stored = ${init};`, `  memcpy(b->data + idx * ${size}, &stored, ${size});`, `}`);
                     }
                 }
             }