@scriptc/compiler 0.0.10 → 0.0.11

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

@@ -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
@@ -798,16 +801,38 @@ 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. Bare "module"
+ * stays a package specifier (an npm package by that name exists); only
+ * the node: spelling names the builtin. */
 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;
+}
+/* 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
@@ -3148,3 +3173,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/dist/backend/emission/emit-exprs.js

@@ -1008,6 +1008,10 @@ export function emitExpr(E, e) {
                     // Omitted relative indices default like string slice: start 0,
                     // end +Infinity (math.h is always included). Fresh copy, +1.
                     return E.newTemp(e.type, `scr_bytes_slice(${r.name}, ${args[0]?.name ?? "0"}, ${args[1]?.name ?? "INFINITY"})`);
+                case "subarray":
+                    // Same defaults; the result is a +1 VIEW aliasing the
+                    // receiver's storage (subarray / Buffer's slice).
+                    return E.newTemp(e.type, `scr_bytes_subarray(${r.name}, ${args[0]?.name ?? "0"}, ${args[1]?.name ?? "INFINITY"})`);
                 case "setFrom": {
                     // dst.set(src, offset?) — void; throws Node's RangeError on
                     // overflow (may-throw seed).
@@ -1063,6 +1067,10 @@ export function emitExpr(E, e) {
                     E.emitPendingCheck();
                     return t;
                 }
+                case "fillElem":
+                    // Per-element TypedArray fill (non-u8): slice-style index
+                    // defaults, never throws; the receiver comes back +1.
+                    return E.newTemp(e.type, `scr_bytes_fill_elem(${r.name}, ${args[0].name}, ${args[1]?.name ?? "0"}, ${args[2]?.name ?? "INFINITY"})`);
                 case "fillStr": {
                     const n = e.args.length - 2;
                     const t = E.newTemp(e.type, `scr_bytes_fill_str(${r.name}, ${args[0].name}, ${args[1].name}, ${n}, ` +
@@ -2477,10 +2485,14 @@ export function emitExpr(E, e) {
                     return finish(`scr_math_max_arr(${arg(0)})`);
                 case "math.minArr":
                     return finish(`scr_math_min_arr(${arg(0)})`);
-                // Math.floor — C floor() IS the JS operation (math.h is always
-                // included). Borrows nothing; no throw.
+                // Math.floor/trunc/ceil — the C functions ARE the JS operations
+                // (math.h is always included). Borrow nothing; no throw.
                 case "math.floor":
                     return finish(`floor(${arg(0)})`);
+                case "math.trunc":
+                    return finish(`trunc(${arg(0)})`);
+                case "math.ceil":
+                    return finish(`ceil(${arg(0)})`);
                 // Math.abs — C fabs IS the JS operation. Math.round — the JS
                 // half-toward-+Infinity rule (scr_lib.c; C round() differs on
                 // halves and naive floor(x+0.5) drifts at the epsilon boundary).
@@ -5097,6 +5109,18 @@ export function emitExpr(E, e) {
                     const list = Array.from({ length: n }, (_, i) => `(ScrStream *)${arg(1 + i)}`).join(", ");
                     return finish(`scr_sp_pipeline(${n}, (ScrStream *[]){ ${list} })`);
                 }
+                case "sc.text":
+                    // stream/consumers: +1 pending promises the accumulate-and-
+                    // settle machinery resolves or rejects (the stream's
+                    // error / premature close / json's SyntaxError).
+                    E.usesTimers = true;
+                    return finish(`scr_sc_text((ScrStream *)${arg(0)})`);
+                case "sc.json":
+                    E.usesTimers = true;
+                    return finish(`scr_sc_json((ScrStream *)${arg(0)})`);
+                case "sc.buffer":
+                    E.usesTimers = true;
+                    return finish(`scr_sc_buffer((ScrStream *)${arg(0)})`);
                 case "readable.newDyn":
                 case "writable.newDyn":
                 case "duplex.newDyn":
@@ -5152,6 +5176,14 @@ export function emitExpr(E, e) {
                 case "readable.pushStr":
                     E.usesTimers = true;
                     return finish(`scr_stream_push_str((ScrStream *)${arg(0)}, ${arg(1)})`);
+                case "readable.pushStrEnc":
+                    // push(chunk, enc) with a literal non-utf8 encoding.
+                    E.usesTimers = true;
+                    return finish(`scr_stream_push_str_enc((ScrStream *)${arg(0)}, ${arg(1)}, ${arg(2)})`);
+                case "readable.pushEncoding":
+                    // The defaultEncoding option's push side (chaining, +1).
+                    E.usesTimers = true;
+                    return finish(`(${cType(e.type).trim()})scr_stream_set_push_encoding((ScrStream *)${arg(0)}, ${arg(1)})`);
                 case "readable.pushNull":
                     E.usesTimers = true;
                     return finish(`scr_stream_push_null((ScrStream *)${arg(0)})`);