@scriptc/compiler 0.0.10 → 0.0.12

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

@@ -246,7 +246,7 @@ declare var process: {
   on(event: "SIGINT" | "SIGTERM", listener: () => void): void;
   on(event: "exit", listener: (code: number) => void): void;
   /* 'warning' — Node's process-warning channel: listeners receive the
-   * warning Error (as a DOM value); emitWarning and the runtime's
+   * warning Error (as a dyn value); emitWarning and the runtime's
    * deprecation sites dispatch synchronously (SEMANTICS.md). */
   on(event: "warning", listener: (warning: Error & { code?: string }) => void): void;
   /* 'unhandledRejection' — dispatched per never-observed rejection at
@@ -266,7 +266,7 @@ declare var process: {
   emitWarning(warning: string | Error, ...args: any[]): void;
 };
 
-/* ── globals a real CLI's sources reference (all @types/node or DOM-lib
+/* ── globals a real CLI's sources reference (all @types/node or dyn-lib
  * territory; the fallback declares the slice so projects PREFLIGHT and
  * every reached use lands on the SC2020 fence — or a real lowering where
  * one exists — instead of "Cannot find name"). With @types/node these
@@ -341,7 +341,7 @@ declare var AbortController: { new (): AbortController };
  * them below): base64 → binary string and back, Latin-1 domain like the
  * WHATWG originals. The parameter is `unknown` because WebIDL ToStrings
  * whatever arrives (Node's atob(null) decodes "null") — the coercion
- * runs in the runtime over the DOM kind, and the Node suite exercises
+ * runs in the runtime over the dyn kind, and the Node suite exercises
  * it; malformed input throws the catchable DOMException
  * InvalidCharacterError, the zero-argument call Node's TypeError
  * [ERR_MISSING_ARGS]. */
@@ -447,7 +447,10 @@ interface Buffer<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> extends
 }
 interface BufferConstructor {
   from(data: string, encoding?: BufferEncoding): Buffer;
-  from(data: Uint8Array | ArrayBuffer | readonly number[]): Buffer;
+  /* The ArrayBuffer form is the VIEW construction: x.buffer with an
+   * optional byte offset/length shares x's storage (the subarray rule). */
+  from(data: ArrayBuffer, byteOffset?: number, length?: number): Buffer;
+  from(data: Uint8Array | readonly number[]): Buffer;
   alloc(size: number, fill?: string | number | Uint8Array, encoding?: BufferEncoding): Buffer;
   compare(buf1: Uint8Array, buf2: Uint8Array): number;
   /* alloc without the zero-fill guarantee — the lowering zero-fills
@@ -708,7 +711,7 @@ declare module "timers/promises" {
  * traceSync/traceCallback run Node's publish choreography in the runtime
  * (context defaults to a fresh {}); tracePromise is declared (the member
  * exists in Node) but fences at the call site — the traced function's
- * promise cannot cross the DOM boundary yet. */
+ * promise cannot cross the checked-dynamic tree boundary yet. */
 declare module "node:diagnostics_channel" {
   export type ChannelListener = (message: unknown, name: string) => void;
   export interface Channel {
@@ -798,16 +801,41 @@ declare module "perf_hooks" {
  * performance.now() either way. */
 declare var performance: import("node:perf_hooks").Performance;
 
-/* node:module — the ADMIT-THEN-FENCE surface: the import compiles (the
- * module carries no evaluation), and every member keeps a per-site fence.
- * createRequire loads CommonJS from disk at runtime — a compiled
- * program's modules are fixed at build time, so the call's fence defers
- * to a runtime error in JS sources (the config-loader idiom is
- * reached only when a CJS config/plugin must load). Bare "module" stays a
- * package specifier (an npm package by that name exists); only the node:
- * spelling names the builtin. */
+/* node:module. createRequire's lowered shape is the version/config-
+ * reading pattern real CLIs ship: a const binding over
+ * createRequire(import.meta.url) (or __filename) whose require calls
+ * take STATIC string literals — the indirection erases at compile time.
+ * A builtin spec makes the binding a namespace import in const clothing;
+ * a relative .json document bakes and parses (JSON.parse's `unknown`
+ * stance — validate with a checked cast); an installed npm package loads
+ * through the island's require-condition entry under --dynamic; a bare
+ * name nothing installed resolves compiles to Node's catchable
+ * MODULE_NOT_FOUND throw (the optional-dependency try/require pattern).
+ * Dynamic specifiers fence: a compiled binary's module graph is fixed at
+ * build time. builtinModules is the baked Node v24 list (a fresh
+ * mutable array per read where Node ships one frozen singleton);
+ * isBuiltin and syncBuiltinESMExports fence per site. Both spellings
+ * name the builtin, like in Node (the builtin wins over the npm package
+ * named "module" for the bare specifier there too). */
 declare module "node:module" {
   export function createRequire(filename: string | URL): (id: string) => unknown;
+  export const builtinModules: string[];
+  export function isBuiltin(moduleName: string): boolean;
+  export function syncBuiltinESMExports(): void;
+}
+declare module "module" {
+  export * from "node:module";
+}
+/* import.meta: module-loader metadata with no value representation —
+ * every read fences (SC1090) EXCEPT as createRequire's base, where it
+ * only NAMES the containing file (import.meta.url, import.meta.filename,
+ * and __filename all mean "this file" there). Declared so the pattern
+ * typechecks under the fallback surface; @types/node's own augmentation
+ * stands in when adopted. */
+interface ImportMeta {
+  url: string;
+  filename: string;
+  dirname: string;
 }
 
 /* The synchronous node:fs surface — utf8-only, no options objects, no
@@ -2498,7 +2526,7 @@ declare module "http2" {
     setTimeout(msecs: number, callback?: () => void): void;
     ping(callback: (err: Error | null, duration: number, payload: Uint8Array) => void): boolean;
     /* The settings surface rides the checked-dynamic machinery (records
-     * cross as DOM values — the suite's mustCall listeners are dyn). */
+     * cross as dyn values — the suite's mustCall listeners are dyn). */
     settings(settings?: any, callback?: any): void;
     readonly localSettings: any;
     readonly remoteSettings: any;
@@ -2761,7 +2789,7 @@ declare module "node:tty" {
 declare module "async_hooks" {
   /* AsyncLocalStorage: fiber-carried context snapshots — run/getStore/
    * exit/enterWith/disable lower onto the runtime's active-slot machinery
-   * (als.* libCalls); values cross as DOM values. */
+   * (als.* libCalls); values cross as dyn values. */
   export class AsyncLocalStorage<T = any> {
     constructor();
     run<R>(store: T, callback: (...args: any[]) => R, ...args: any[]): R;
@@ -3148,3 +3176,23 @@ declare module "node:stream/promises" {
   import streamPromises = require("stream/promises");
   export = streamPromises;
 }
+declare module "stream/consumers" {
+  /* The promise consumers over a readable: accumulate every chunk and
+   * settle — text (the utf8 decode), json (the text through JSON.parse:
+   * `unknown`, validated with a checked cast; malformed input rejects
+   * with the parse's SyntaxError), buffer (the concatenated bytes;
+   * string chunks contribute their utf8 bytes, Node's Blob rule).
+   * Stream errors reject; an early close rejects with
+   * ERR_STREAM_PREMATURE_CLOSE. arrayBuffer and blob fence per site:
+   * neither value has a representation in a compiled binary. */
+  function text(stream: unknown): Promise<string>;
+  function json(stream: unknown): Promise<unknown>;
+  function buffer(stream: unknown): Promise<Buffer>;
+  function arrayBuffer(stream: unknown): Promise<ArrayBuffer>;
+  function blob(stream: unknown): Promise<unknown>;
+  export { arrayBuffer, blob, buffer, json, text };
+}
+declare module "node:stream/consumers" {
+  import streamConsumers = require("stream/consumers");
+  export = streamConsumers;
+}

package/ambient/scriptc.d.ts

@@ -1,12 +1,12 @@
 /* scriptc's shipped declarations — the ALWAYS-SHIPPED CORE. Programs
  * compile against the REAL TypeScript standard library (lib.es2023, no
- * DOM, no @types): the checker sees the full standard surface, and the
+ * dyn, no @types): the checker sees the full standard surface, and the
  * LOWERER is the scope fence — any reached use of standard-library surface
  * without a lowering is a SC2020 diagnostic at its use site. This file
  * declares only what the es2023 lib does not:
  *
  * 1. scriptc's own primitives (comptime, __island_eval).
- * 2. setTimeout/clearTimeout and the Timeout handle (Node/DOM territory the
+ * 2. setTimeout/clearTimeout and the Timeout handle (Node/dyn territory the
  *    lib files don't cover; plain declarations, so with @types/node present
  *    they MERGE as overloads instead of colliding — the Timeout handle maps
  *    to the numeric timer id either way, and .unref()/.ref()/.hasRef() are

package/dist/backend/cc.d.ts

@@ -65,12 +65,12 @@ export interface CcOptions {
     dynInvoke?: boolean;
     /** The program uses the diagnostics_channel surface (index.ts detects
      * dc.* libCalls on the IR): compiles scr_dc.c — pure data structure
-     * over the DOM (no loop hooks, no install), cross-compiles everywhere.
+     * over the checked-dynamic tree (no loop hooks, no install), cross-compiles everywhere.
      * Channel-free binaries keep their exact size class. */
     dc?: boolean;
     /** The program uses the checked-dynamic async surfaces
      * (moduleUsesDynAsync on the IR, or the dynInvoke/dc gates — their TUs
-     * call into this one): compiles scr_async_dyn.c — DOM-promise
+     * call into this one): compiles scr_async_dyn.c — dyn-promise
      * reactions, AsyncLocalStorage, the unhandledRejection/warning
      * process events. */
     dynAsync?: boolean;

package/dist/backend/emission/emit-async.js

@@ -902,7 +902,7 @@ export function streamCbThunkFor(E, kind, cbT) {
         const isDonePos = kind === "e" ? false
             : (kind === "w" || kind === "t") ? pos === 2 : (kind === "f" || kind === "l") ? pos === 0 : pos === 1;
         // The JS lane's implicitly-any parameters: each position boxes into
-        // dyn by kind — the chunk as DOM bytes, the encoding as a string,
+        // dyn by kind — the chunk as dyn bytes, the encoding as a string,
         // the error as the boundary's {name, message} shape (null when
         // none), and the completion callback as a CALLABLE dyn whose glue
         // dispatches to the runtime's *_done entry (the closure's one cap