@scriptc/compiler 0.0.22 → 0.0.24

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

@@ -205,12 +205,18 @@ declare var process: {
   /* The raw byte writes — no newline, no formatting. stdout shares
    * console.log's stream, each call is submitted promptly, and ordering is
    * preserved. The boolean is Node's backpressure signal — these synchronous
-   * writes always return true. The Uint8Array overload
-   * and isTTY exist so real CLIs TYPECHECK (they are @types/node surface);
-   * only the one-string form has a lowering — everything else fences at
-   * its use site. */
-  stdout: { write(data: string): boolean; write(data: Uint8Array): boolean; readonly isTTY: boolean };
-  stderr: { write(data: string): boolean; write(data: Uint8Array): boolean; readonly isTTY: boolean };
+   * writes always return true. Static BufferEncoding arguments and the
+   * completion callback overloads match Node's WritableStream surface. */
+  stdout: {
+    write(data: string | Uint8Array, callback?: (error?: Error | null) => void): boolean;
+    write(data: string | Uint8Array, encoding: BufferEncoding, callback?: (error?: Error | null) => void): boolean;
+    readonly isTTY: boolean;
+  };
+  stderr: {
+    write(data: string | Uint8Array, callback?: (error?: Error | null) => void): boolean;
+    write(data: string | Uint8Array, encoding: BufferEncoding, callback?: (error?: Error | null) => void): boolean;
+    readonly isTTY: boolean;
+  };
   /* The stdin stream, the piped-input slice: the TTY probe, the
    * data/end/error events (on and once — a 'data' listener keeps the
    * event loop alive until EOF, like Node's flowing stdin), destroy()
@@ -475,8 +481,8 @@ declare var Buffer: BufferConstructor;
 
 /* The WHATWG encoders (Node globals). The COMPOSED forms lower —
  * `new TextEncoder().encode(s)` and `new TextDecoder().decode(bytes)` —
- * as do same-scope const store-then-call forms. The label is typed as the
- * utf-8 spellings (the one supported decoder; other labels and the
+ * as do same-scope const store-then-call forms. Recognized literal WHATWG
+ * labels compile statically; runtime-valued/unknown labels and the
  * fatal/ignoreBOM options fence at the use site). */
 interface TextEncoder {
   encode(input?: string): Uint8Array;
@@ -485,7 +491,7 @@ declare var TextEncoder: { new (): TextEncoder };
 interface TextDecoder {
   decode(input?: ArrayBufferView | ArrayBuffer): string;
 }
-declare var TextDecoder: { new (label?: "utf-8" | "utf8"): TextDecoder };
+declare var TextDecoder: { new (label?: string): TextDecoder };
 
 /* The WHATWG event surface (Node globals since v15): declared so the
  * suite's event-plumbing tests typecheck and fence per SITE with the
@@ -688,6 +694,36 @@ interface Response {
   arrayBuffer(): Promise<ArrayBuffer>;
   bytes(): Promise<Uint8Array>;
 }
+interface ResponseInit {
+  headers?:
+    | Headers
+    | Record<string, string>
+    | readonly (readonly [string, string])[];
+  status?: number;
+  statusText?: string;
+}
+declare var Response: {
+  new (
+    body?: string | Uint8Array | ReadableStream<Uint8Array> | null,
+    init?: ResponseInit,
+  ): Response;
+  readonly prototype: Response;
+  error(): Response;
+  json(data: unknown, init?: ResponseInit): Response;
+  redirect(url: string | URL, status?: number): Response;
+};
+interface Request {
+  readonly method: string;
+  readonly url: string;
+  readonly headers: Headers;
+  readonly signal: AbortSignal;
+  readonly body: ReadableStream<Uint8Array> | null;
+  readonly bodyUsed: boolean;
+  json(): Promise<unknown>;
+  text(): Promise<string>;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  bytes(): Promise<Uint8Array>;
+}
 interface RequestInit {
   method?: string;
   headers?:
@@ -699,6 +735,10 @@ interface RequestInit {
   redirect?: "follow" | "error" | "manual";
   signal?: AbortSignal;
 }
+declare var Request: {
+  new (input: string | URL | Request, init?: RequestInit): Request;
+  readonly prototype: Request;
+};
 declare function fetch(input: string | URL, init?: RequestInit): Promise<Response>;
 
 /* The repeating timer pair (setTimeout lives in scriptc.d.ts — always
@@ -941,6 +981,8 @@ declare module "node:fs" {
   /* The 2-argument form only (Node's mode flags have no lowering). The
    * destination is created or truncated carrying the SOURCE's mode. */
   export function copyFileSync(src: string, dest: string): void;
+  export function rename(oldPath: string, newPath: string, callback: (err: NodeJS.ErrnoException | null) => void): void;
+  export function renameSync(oldPath: string, newPath: string): void;
   export function rmSync(path: string): void;
   /* maxRetries/retryDelay are accepted no-ops (Node retries around
    * EBUSY-class races; the synchronous lowering has no re-entrancy that
@@ -976,12 +1018,16 @@ declare module "node:fs" {
   };
   /* A stat(2) snapshot (statSync follows symlinks, lstatSync does not —
    * Node's split) — immutable; the supported surface is exactly these
-   * members. mtimeMs is milliseconds with the nanosecond fraction. */
+   * members. blocks is the allocated size in 512-byte units; the time
+   * fields are milliseconds with their sub-second fractions. */
   export interface Stats {
     isFile(): boolean;
     isDirectory(): boolean;
     isSymbolicLink(): boolean;
     readonly size: number;
+    readonly blocks: number;
+    readonly nlink: number;
+    readonly atimeMs: number;
     readonly mtimeMs: number;
   }
   export function statSync(path: string): Stats;
@@ -991,10 +1037,15 @@ declare module "node:fs" {
    * variants), closeSync(fd). */
   export function openSync(path: string, flags: string): number;
   export function closeSync(fd: number): void;
-  /* read(2) into a caller buffer from the fd's current position (the
-   * position argument is declared for parity and fences when non-null);
-   * answers the byte count, 0 at EOF. */
+  /* Read into a caller buffer from the fd's current position when position
+   * is omitted/null, or from a numeric byte position without advancing the
+   * fd. Answers the byte count, 0 at EOF. */
   export function readSync(fd: number, buffer: Uint8Array, offset: number, length: number, position?: number | null): number;
+  /* Write a caller-buffer window, or a utf8 string, at the fd's current
+   * position when position is omitted/null (advancing it), or at a numeric
+   * byte position without advancing it. Answers the byte count. */
+  export function writeSync(fd: number, buffer: Uint8Array, offset: number, length: number, position?: number | null): number;
+  export function writeSync(fd: number, string: string, position?: number | null, encoding?: "utf8" | "utf-8"): number;
   /* statSync over an open fd — the same Stats snapshot. */
   export function fstatSync(fd: number): Stats;
   /* realpath(3) — resolves symlinks, `.`/`..`, throwing Node's fs error
@@ -1056,15 +1107,52 @@ declare module "fs" {
  * interleaves with timers or other fibers — observable only in concurrent
  * code. readFile is utf8-only, like readFileSync. */
 declare module "fs/promises" {
+  export interface FileReadResult<T extends Uint8Array> {
+    bytesRead: number;
+    buffer: T;
+  }
+  export interface FileWriteResult<T> {
+    bytesWritten: number;
+    buffer: T;
+  }
+  export interface FileHandle {
+    readonly fd: number;
+    close(): Promise<void>;
+    read<T extends Uint8Array>(
+      buffer: T,
+      offset?: number | null,
+      length?: number | null,
+      position?: number | null,
+    ): Promise<FileReadResult<T>>;
+    write<T extends Uint8Array>(
+      buffer: T,
+      offset?: number | null,
+      length?: number | null,
+      position?: number | null,
+    ): Promise<FileWriteResult<T>>;
+    write(data: string, position?: number | null, encoding?: "utf8" | "utf-8" | null): Promise<FileWriteResult<string>>;
+    readFile(options?: null): Promise<Buffer>;
+    readFile(encoding: "utf8" | "utf-8"): Promise<string>;
+    writeFile(data: string | Uint8Array, encoding?: "utf8" | "utf-8" | null): Promise<void>;
+    appendFile(data: string | Uint8Array, encoding?: "utf8" | "utf-8" | null): Promise<void>;
+    stat(): Promise<import("node:fs").Stats>;
+  }
+  export function open(path: string, flags?: string, mode?: number): Promise<FileHandle>;
   export function readFile(path: string, encoding: "utf8" | "utf-8"): Promise<string>;
   export function readFile(path: string): Promise<Buffer>;
-  export function writeFile(path: string, data: string): Promise<void>;
+  export function writeFile(
+    path: string,
+    data: string,
+    options?: { mode?: number; encoding?: "utf8" | "utf-8"; flag?: string; [option: string]: unknown },
+  ): Promise<void>;
+  export function writeFile(path: string, data: string, encoding: "utf8" | "utf-8"): Promise<void>;
   export function mkdir(path: string, options?: { recursive?: boolean; mode?: number }): Promise<void>;
   export function readdir(path: string): Promise<string[]>;
   export function rm(path: string): Promise<void>;
   export function stat(path: string): Promise<import("node:fs").Stats>;
   export function unlink(path: string): Promise<void>;
   export function chmod(path: string, mode: number): Promise<void>;
+  export function rename(oldPath: string, newPath: string): Promise<void>;
 }
 declare module "node:fs/promises" {
   export * from "fs/promises";
@@ -1550,6 +1638,41 @@ declare module "util" {
     format?: unknown,
     ...args: unknown[]
   ): string;
+  export type ParseArgsOptionsType = "boolean" | "string";
+  export interface ParseArgsOptionDescriptor {
+    type: ParseArgsOptionsType;
+    multiple?: boolean;
+    short?: string;
+    default?: string | boolean | string[] | boolean[];
+  }
+  export interface ParseArgsOptionsConfig {
+    [longOption: string]: ParseArgsOptionDescriptor;
+  }
+  export interface ParseArgsConfig {
+    args?: readonly string[];
+    options?: ParseArgsOptionsConfig;
+    strict?: boolean;
+    allowPositionals?: boolean;
+    allowNegative?: boolean;
+    tokens?: boolean;
+  }
+  export type ParseArgsToken =
+    | {
+        kind: "option";
+        index: number;
+        name: string;
+        rawName: string;
+        value: string | undefined;
+        inlineValue: boolean | undefined;
+      }
+    | { kind: "positional"; index: number; value: string }
+    | { kind: "option-terminator"; index: number };
+  export interface ParseArgsResult {
+    values: { [longOption: string]: undefined | string | boolean | Array<string | boolean> };
+    positionals: string[];
+    tokens?: ParseArgsToken[];
+  }
+  export function parseArgs(config?: ParseArgsConfig): ParseArgsResult;
   /* util.getCallSites (Node ≥22.9): the captured-frame slice harness
    * code reads. No stack bookkeeping exists in a compiled binary — every
    * reached call fences per site. */
@@ -1996,6 +2119,8 @@ declare module "node:net" {
 declare module "http" {
   import { Server as NetServer, Socket } from "net";
   export type Server = NetServer;
+  export type RequestListener =
+    (req: IncomingMessage, res: ServerResponse) => void;
   /* The Server VALUE — Node's constructor works with and without `new`
    * (test/parallel's http.Server(fn) spelling); both route to the
    * createServer lowering. */

package/dist/backend/cc.d.ts

@@ -46,6 +46,15 @@ export interface CcOptions {
      * implemented in scr_copying.c (index.ts detects them on the IR).
      * Off keeps that optional TU out of unrelated binaries. */
     copying?: boolean;
+    /** The program uses a statically-labelled non-UTF-8 TextDecoder. Its
+     * generated mapping tables live behind SCR_TEXT_DECODER_LEGACY so the
+     * always-compiled bytes TU stays in the historical size class otherwise. */
+    textDecoderLegacy?: boolean;
+    /** The program uses fs/promises.open or a FileHandle value
+     * (moduleUsesFileHandle on the IR): compiles scr_file_handle.c. Keeping
+     * the descriptor object and promise adapters in their own unit preserves
+     * the base runtime's size class for programs that never open a handle. */
+    fileHandle?: boolean;
     /** The embedded npm graph references fetch (index.ts detects it on the
      * IR): compiles the NATIVE fetch bridge (scr_fetch.c over scr_net +
      * scr_tls + scr_http's client parser + zlib — the socket units join
@@ -134,6 +143,9 @@ export interface CcOptions {
      * line (escape-only programs ride the always-linked component encoder
      * and never flip this). */
     qs?: boolean;
+    /** The program uses static util.parseArgs (index.ts detects its libCall):
+     * compiles scr_util.c, a pure checked-dynamic data transform. */
+    parseArgs?: boolean;
     /** The program uses the node:stream class surface (moduleUsesStream on
      * the IR): compiles scr_stream.c into the binary — always alongside
      * scr_events_emitter.c, which moduleUsesEmitter answers true for
@@ -242,6 +254,7 @@ export interface LibArchiveOptions {
     emitter?: boolean;
     zlib?: boolean;
     copying?: boolean;
+    textDecoderLegacy?: boolean;
 }
 export declare function compileLibArchive(opts: LibArchiveOptions): Promise<void>;
 /** Resolve the build cache without touching the filesystem. Exported from this

package/dist/backend/cc.js

@@ -732,6 +732,7 @@ export async function compileLibArchive(opts) {
         "-fno-strict-aliasing", // the emitted object model type-puns — see compileC's buildArgs
         "-Wno-deprecated-declarations",
         "-DSCR_LIB",
+        ...(opts.textDecoderLegacy ? ["-DSCR_TEXT_DECODER_LEGACY"] : []),
         "-I", rtDir,
         ...(regex ? ["-I", vendorEngineDir()] : []),
         ...(opts.zlib ? ["-I", vendorZlibDir()] : []),
@@ -2166,6 +2167,9 @@ export async function compileC(opts) {
     const http = (opts.http ?? false) || nativeFetch || netIsland;
     const tls = (opts.tls ?? false) || nativeFetch || netIsland;
     const driver = resolveCc();
+    // scr_async.c submits callback-style filesystem work to a native worker.
+    // POSIX drivers need the thread compile/link mode; win32 uses CreateThread.
+    const threadArgs = targetPlatform(driver) === "win32" ? [] : ["-pthread"];
     if (driver.target !== null) {
         // See the resolveCc block: these inputs are built on and for the HOST
         // (vendored archives, system libs). Regex, zlib, and the engine archive
@@ -2290,9 +2294,11 @@ export async function compileC(opts) {
     const buildArgs = (rt, build = {}) => [
         "-std=c11",
         ...driver.targetArgs,
+        ...threadArgs,
         ...(sanitize
             ? ["-O1", "-fsanitize=address", "-DSCR_RC_AUDIT"]
             : ["-O2"]),
+        ...(opts.textDecoderLegacy ? ["-DSCR_TEXT_DECODER_LEGACY"] : []),
         "-fno-math-errno",
         // The emitted object model is deliberately type-punned C: a hierarchy
         // upcast is a raw pointer cast, so one object's header (rc, vt) and
@@ -2310,6 +2316,7 @@ export async function compileC(opts) {
         "-I", rtDir,
         ...RUNTIME_SOURCES.map((f) => rt(join(rtDir, f))),
         ...(opts.copying ? [rt(join(rtDir, "scr_copying.c"))] : []),
+        ...(opts.fileHandle ? [rt(join(rtDir, "scr_file_handle.c"))] : []),
         // win32 targets compile the libc-shim TU (stpcpy, arc4random_buf,
         // gmtime_r, strcasestr — the _WIN32 block in scr_runtime.h declares
         // them) and link advapi32 (the CSPRNG RtlGenRandom/SystemFunction036,
@@ -2354,6 +2361,7 @@ export async function compileC(opts) {
         ...(opts.symbol ? [rt(join(rtDir, "scr_symbol.c"))] : []),
         ...(opts.searchParams ? [rt(join(rtDir, "scr_url_params.c"))] : []),
         ...(opts.qs ? [rt(join(rtDir, "scr_qs.c"))] : []),
+        ...(opts.parseArgs ? [rt(join(rtDir, "scr_util.c"))] : []),
         ...(opts.stream ? [rt(join(rtDir, "scr_stream.c"))] : []),
         // The readiness-poller backends (scr_platform.h): kqueue on macOS/BSD,
         // epoll on Linux, WSAPoll on Windows — each TU is empty off its
@@ -2472,9 +2480,11 @@ export async function compileC(opts) {
     const cflags = [
         "-std=c11",
         ...driver.targetArgs,
+        ...threadArgs,
         ...(sanitize
             ? ["-O1", "-fsanitize=address", "-DSCR_RC_AUDIT"]
             : ["-O2"]),
+        ...(opts.textDecoderLegacy ? ["-DSCR_TEXT_DECODER_LEGACY"] : []),
         "-fno-math-errno",
         "-fno-strict-aliasing", // the emitted object model type-puns — see buildArgs
         "-Wno-deprecated-declarations",
@@ -2573,6 +2583,7 @@ export async function compileC(opts) {
     }
     const linkProbeArgs = [
         ...(sanitize ? ["-fsanitize=address"] : []),
+        ...threadArgs,
         ...(targetPlatform(driver) === "win32"
             ? ["-ladvapi32", "-liphlpapi", "-lws2_32"]
             : []),