@scriptc/compiler 0.2.1 → 0.2.2

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

@@ -201,6 +201,7 @@ declare var process: {
   umask(mask?: number): number;
   /* chdir(2) — failures throw Node's fs-shaped catchable error. */
   chdir(directory: string): void;
+  loadEnvFile(path?: string | URL | Uint8Array): void;
   /* The extra CLI arguments Node itself consumed (--expose-internals,
    * ...): a compiled binary consumed none, so this is always []. */
   readonly execArgv: string[];
@@ -1172,6 +1173,10 @@ declare module "node:fs" {
   export function openSync(path: string, flags: string): number;
   export function openSync(path: string, flags: number, mode?: number): number;
   export function closeSync(fd: number): void;
+  export function fdatasyncSync(fd: number): void;
+  export function ftruncateSync(fd: number, len?: number): void;
+  export function readvSync(fd: number, buffers: Uint8Array[], position?: number | null): number;
+  export function writevSync(fd: number, buffers: Uint8Array[], position?: number | null): number;
   /* 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. */
@@ -1265,9 +1270,31 @@ declare module "fs/promises" {
     bytesWritten: number;
     buffer: T;
   }
+  export interface FileReadvResult<T extends Uint8Array[]> {
+    bytesRead: number;
+    buffers: T;
+  }
+  export interface FileWritevResult<T extends Uint8Array[]> {
+    bytesWritten: number;
+    buffers: T;
+  }
+  export interface FileReadOptions<T extends Uint8Array = Buffer> {
+    buffer?: T;
+    offset?: number | null;
+    length?: number | null;
+    position?: number | null;
+  }
   export interface FileHandle extends AsyncDisposable {
     readonly fd: number;
     close(): Promise<void>;
+    sync(): Promise<void>;
+    datasync(): Promise<void>;
+    truncate(len?: number): Promise<void>;
+    chmod(mode: number): Promise<void>;
+    readv<T extends Uint8Array[]>(buffers: T, position?: number | null): Promise<FileReadvResult<T>>;
+    writev<T extends Uint8Array[]>(buffers: T, position?: number | null): Promise<FileWritevResult<T>>;
+    read<T extends Uint8Array = Buffer>(options?: FileReadOptions<T> | null): Promise<FileReadResult<T>>;
+    read<T extends Uint8Array>(buffer: T, options: Omit<FileReadOptions<T>, "buffer">): Promise<FileReadResult<T>>;
     read<T extends Uint8Array>(
       buffer: T,
       offset?: number | null,
@@ -1280,6 +1307,7 @@ declare module "fs/promises" {
       length?: number | null,
       position?: number | null,
     ): Promise<FileWriteResult<T>>;
+    write<T extends Uint8Array>(buffer: T, options: Omit<FileReadOptions<T>, "buffer">): 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>;
@@ -1438,12 +1466,13 @@ declare module "node:os" {
 }
 
 /* The WHATWG URL class (a Node global; the es2023 lib doesn't declare it),
- * typed as exactly the supported surface: construction from ONE absolute-
- * URL string (invalid input throws a catchable TypeError, like Node), the
+ * typed as exactly the supported surface: construction from an input and
+ * optional base (invalid input throws a catchable TypeError, like Node), the
  * protocol/origin/username/pathname/href/host/hostname/port/search/hash getters, searchParams (the
  * LIVE query view — mutations through it re-serialize into the URL, so
  * href reflects immediately; every read answers the same object, Node's
- * caching), and toString() (the href serialization).
+ * caching), toString()/toJSON() (href serialization), and the non-throwing
+ * canParse()/parse() factories (conversion errors still propagate).
  * URL values have no SETTERS — the component fields are read-only (the
  * one supported mutation path is searchParams) — and participate in
  * unions (URL | undefined). The parser covers the common CLI schemes
@@ -1464,9 +1493,12 @@ interface URL {
   readonly hash: string;
   readonly searchParams: URLSearchParams;
   toString(): string;
+  toJSON(): string;
 }
 declare var URL: {
   new (input: string | { toString: () => string }, base?: string | URL): URL;
+  canParse(input: string | URL, base?: string | URL): boolean;
+  parse(input: string | URL, base?: string | URL): URL | null;
 };
 
 /* URLSearchParams — the WHATWG application/x-www-form-urlencoded list.
@@ -1499,6 +1531,10 @@ declare var URLSearchParams: {
  * slashes, non-empty host); pathToFileURL resolves the path and percent-
  * encodes it into a file: URL. */
 declare module "url" {
+  export type URL = globalThis.URL;
+  export type URLSearchParams = globalThis.URLSearchParams;
+  export const URL: typeof globalThis.URL;
+  export const URLSearchParams: typeof globalThis.URLSearchParams;
   export function fileURLToPath(url: string | URL): string;
   export function pathToFileURL(path: string, options?: { windows?: boolean }): URL;
 }
@@ -1506,7 +1542,7 @@ declare module "node:url" {
   export * from "url";
 }
 
-/* node:crypto: the static hashing/MAC/random/PBKDF2 utility slice. */
+/* node:crypto: the static hashing/MAC/random/key-derivation utility slice. */
 declare module "crypto" {
   export function randomUUID(): string;
   export function randomBytes(size: number): Buffer;
@@ -1531,6 +1567,21 @@ declare module "crypto" {
   export function pbkdf2Sync(password: string | Uint8Array, salt: string | Uint8Array, iterations: number, keylen: number, digest: string): Buffer;
   export function pbkdf2(password: string | Uint8Array, salt: string | Uint8Array, iterations: number, keylen: number, digest: string, callback: (error: Error | null, derivedKey: Buffer) => void): void;
   export function randomBytes(size: number, callback: (error: Error | null, buffer: Buffer) => void): void;
+  export type BinaryLike = string | ArrayBuffer | ArrayBufferView;
+  export interface ScryptOptions {
+    N?: number;
+    r?: number;
+    p?: number;
+    cost?: number;
+    blockSize?: number;
+    parallelization?: number;
+    maxmem?: number;
+  }
+  export function scryptSync(password: BinaryLike, salt: BinaryLike, keylen: number, options?: ScryptOptions): Buffer;
+  export function scrypt(password: BinaryLike, salt: BinaryLike, keylen: number, callback: (error: Error | null, derivedKey: Buffer) => void): void;
+  export function scrypt(password: BinaryLike, salt: BinaryLike, keylen: number, options: ScryptOptions, callback: (error: Error | null, derivedKey: Buffer) => void): void;
+  export function hkdfSync(digest: string, ikm: BinaryLike, salt: BinaryLike, info: BinaryLike, keylen: number): ArrayBuffer;
+  export function hkdf(digest: string, ikm: BinaryLike, salt: BinaryLike, info: BinaryLike, keylen: number, callback: (error: Error | null, derivedKey: ArrayBuffer) => void): void;
   /* The lowered X509Certificate surface is the data-record slice:
    * fingerprint (the SHA-1 of the DER, uppercase colon-separated) and
    * the validFrom/validTo validity window (Node's ASN1_TIME_print
@@ -1832,6 +1883,7 @@ declare module "node:child_process" {
  * the latter resolves the callback's data argument. Other targets and bare
  * promisify values fence per site. */
 declare module "util" {
+  export function parseEnv(content: string): { [key: string]: string | undefined };
   export type TextEncoder = globalThis.TextEncoder;
   export type TextDecoder = globalThis.TextDecoder;
   export var TextEncoder: typeof globalThis.TextEncoder;
@@ -3397,6 +3449,9 @@ declare module "node:worker_threads" {
  * third-party .d.ts files that `import { Buffer } from "node:buffer"` —
  * file-entry-cache in a typed-JS source graph — typecheck). */
 declare module "buffer" {
+  export function isAscii(input: ArrayBuffer | ArrayBufferView): boolean;
+  export function isUtf8(input: ArrayBuffer | ArrayBufferView): boolean;
+  export function transcode(source: Uint8Array, fromEncoding: string, toEncoding: string): Buffer;
   export function atob(data: string): string;
   export function btoa(data: string): string;
   export const kMaxLength: number;

package/dist/backend/llvm/dyn.d.ts

@@ -26,6 +26,9 @@ export interface DynHost extends WalkerHost {
         snapshot: string;
         commit: string;
     };
+    liveDynUnionRefAdapter(t: IrType & {
+        kind: "union";
+    }): string;
     dynPromiseAdapter(t: IrType): string;
     isErrorClass(className: string): boolean;
     classSubtypes(className: string): readonly string[];

package/dist/backend/llvm/dyn.js

@@ -2,7 +2,7 @@ import { typedRefConstructor } from "./shapes.js";
 import { BYTES_ELEM_NUM, f64Lit } from "./common.js";
 import { InternalCompilerError } from "../../errors.js";
 import { DYN_HANDLE_KINDS, isDynTypedRefType, isRefCounted, typeKey } from "../../ir/ir.js";
-import { dynDesc } from "../../ir/analysis.js";
+import { dynDesc, streamTypedRefEligible } from "../../ir/analysis.js";
 import { mangleRecordNew, mangleRecordStruct } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
 import { llvmCommentText } from "./common.js";
@@ -108,9 +108,25 @@ export class LlDyn {
             const ty = this.valTy(type);
             const unpack = ty === "double" ? "bitcast i64 %slot to double" : ty === "i1" ? "trunc i64 %slot to i1" : "inttoptr i64 %slot to ptr";
             const pack = ty === "double" ? "bitcast double %value to i64" : ty === "i1" ? "zext i1 %value to i64" : "ptrtoint ptr %value to i64";
-            const box = this.toDynHelper(type);
+            // Collection reads expose the original mutable element, including
+            // records/arrays inside unions, rather than a detached dyn snapshot.
+            const B = new BlockBuilder();
+            B.line(`%value = ${unpack}`);
+            if (type.kind === "union" && this.host.unionsById.get(type.unionId)?.arms.some(streamTypedRefEligible)) {
+                B.line(`%result = call ptr @${this.host.liveDynUnionRefAdapter(type)}(ptr %value)`);
+            }
+            else if (type.kind === "record" || type.kind === "array") {
+                const adapter = this.host.liveDynRefAdapter(type);
+                const rc = vAdapters(this.host, type);
+                const typeId = typeKey(type);
+                B.line(`%result = call ptr ${typedRefConstructor(this.host, type)}(ptr %value, ptr ${rc.retain}, ptr ${rc.release}, ptr ${this.host.cstr(typeId)}, ${this.S} ${Buffer.byteLength(typeId, "utf8")}, ptr @${adapter.snapshot}, ptr ${adapter.commit})`);
+            }
+            else {
+                B.line(`%result = call ptr @${this.toDynHelper(type)}(${ty} %value)`);
+            }
+            B.terminate("ret ptr %result");
             const unbox = this.dynCheckHelper(type);
-            this.defs.push(`define internal ptr @${name}_${role}_box(i64 %slot) ${FN_ATTRS} {`, `  %value = ${unpack}`, `  %result = call ptr @${box}(${ty} %value)`, `  ret ptr %result`, `}`, "", `define internal i64 @${name}_${role}_unbox(ptr %d) ${FN_ATTRS} {`, `  %value = call ${ty === "i1" ? "zeroext i1" : ty} @${unbox}(ptr %d, ptr null)`, `  %result = ${pack}`, `  ret i64 %result`, `}`, "");
+            this.defs.push(`define internal ptr @${name}_${role}_box(i64 %slot) ${FN_ATTRS} {`, B.render(), `}`, "", `define internal i64 @${name}_${role}_unbox(ptr %d) ${FN_ATTRS} {`, `  %value = call ${ty === "i1" ? "zeroext i1" : ty} @${unbox}(ptr %d, ptr null)`, `  %result = ${pack}`, `  ret i64 %result`, `}`, "");
         };
         emitSlot(keyType, "key");
         emitSlot(valueType, "value");
@@ -436,7 +452,12 @@ export class LlDyn {
                 break;
             }
             case "func":
-                kindIs(DYN_KIND.FUNC);
+                this.host.declare(`declare zeroext i1 @scr_dyn_is_callable(ptr)`);
+                {
+                    const matched = B.tmp();
+                    B.line(`${matched} = call zeroext i1 @scr_dyn_is_callable(ptr %d)`);
+                    B.terminate(`ret i1 ${matched}`);
+                }
                 break;
             case "classval": {
                 this.host.declare(`declare zeroext i1 @scr_dyn_class_is(ptr, ptr)`);
@@ -584,7 +605,16 @@ export class LlDyn {
                 B.startBlock(l0);
                 const n = this.lenOf(B, "%d");
                 const items = this.itemsOf(B, "%d");
-                this.i64Loop(B, "dm.el", n, (i) => {
+                this.i64Loop(B, "dm.el", n, (i, brNext) => {
+                    this.host.declare(`declare zeroext i1 @scr_dyn_arr_has_index(ptr, ${this.S})`);
+                    const present = B.tmp();
+                    B.line(`${present} = call zeroext i1 @scr_dyn_arr_has_index(ptr %d, ${this.S} ${i})`);
+                    const valueLabel = B.newLabel("dm.present");
+                    const holeLabel = B.newLabel("dm.hole");
+                    B.condBr(present, valueLabel, holeLabel);
+                    B.startBlock(holeLabel);
+                    brNext();
+                    B.startBlock(valueLabel);
                     const e = this.itemAt(B, items, i);
                     const ok = B.tmp();
                     B.line(`${ok} = call zeroext i1 @${m}(ptr ${e})`);
@@ -1170,6 +1200,22 @@ export class LlDyn {
                 const accTy = acc === "f64" ? "double" : acc === "bool" ? "i1" : "ptr";
                 host.declare(`declare double @scr_arr_push_${acc}(ptr, ${acc === "bool" ? "i1 zeroext" : accTy})`);
                 this.i64Loop(B, "dca", n, (i) => {
+                    host.declare(`declare zeroext i1 @scr_dyn_arr_has_index(ptr, ${this.S})`);
+                    const present = B.tmp();
+                    B.line(`${present} = call zeroext i1 @scr_dyn_arr_has_index(ptr %d, ${this.S} ${i})`);
+                    const valueLabel = B.newLabel("dca.present");
+                    const holeLabel = B.newLabel("dca.hole");
+                    const doneLabel = B.newLabel("dca.done");
+                    B.condBr(present, valueLabel, holeLabel);
+                    B.startBlock(holeLabel);
+                    host.declare(`declare void @scr_arr_set_len(ptr, double)`);
+                    const index = B.tmp();
+                    const length = B.tmp();
+                    B.line(`${index} = uitofp ${this.S} ${i} to double`);
+                    B.line(`${length} = fadd double ${index}, 1.0`);
+                    B.line(`call void @scr_arr_set_len(ptr ${a}, double ${length})`);
+                    B.br(doneLabel);
+                    B.startBlock(valueLabel);
                     const pp = B.tmp();
                     const kp = B.tmp();
                     const ip = B.tmp();
@@ -1188,6 +1234,8 @@ export class LlDyn {
                     }, "ptr null");
                     const pushed = B.tmp();
                     B.line(`${pushed} = call double @scr_arr_push_${acc}(ptr ${a}, ${accTy} ${v})`);
+                    B.br(doneLabel);
+                    B.startBlock(doneLabel);
                 });
                 B.terminate(`ret ptr ${a}`);
                 break;
@@ -1316,7 +1364,22 @@ export class LlDyn {
                 // caps[0] obj-box owns the dyn value (untraced).
                 const adapter = this.dynFuncAdapterHelper(t);
                 const sigLit = host.cstr(key);
-                requireKind(DYN_KIND.FUNC, "dcf");
+                const lWrap = B.newLabel("dcf.w");
+                host.declare(`declare zeroext i1 @scr_dyn_is_callable(ptr)`);
+                const callable = B.tmp();
+                const valid = B.newLabel("dcf.k");
+                const invalid = B.newLabel("dcf.f");
+                B.line(`${callable} = call zeroext i1 @scr_dyn_is_callable(ptr %d)`);
+                B.condBr(callable, valid, invalid);
+                B.startBlock(invalid);
+                B.line(`call void @scr_dyn_check_fail(ptr %path, ptr ${want}, ptr %d)`);
+                B.terminate(`ret ${dummy}`);
+                B.startBlock(valid);
+                const direct = B.tmp();
+                const lSignature = B.newLabel("dcf.signature");
+                B.line(`${direct} = icmp eq i32 ${this.kindOf(B, "%d")}, ${DYN_KIND.FUNC}`);
+                B.condBr(direct, lSignature, lWrap);
+                B.startBlock(lSignature);
                 host.declare(`declare i32 @strcmp(ptr, ptr)`);
                 const sigp = B.tmp();
                 const sig = B.tmp();
@@ -1327,7 +1390,6 @@ export class LlDyn {
                 B.line(`${cmp} = call i32 @strcmp(ptr ${sig}, ptr ${sigLit})`);
                 B.line(`${same} = icmp eq i32 ${cmp}, 0`);
                 const lSame = B.newLabel("dcf.s");
-                const lWrap = B.newLabel("dcf.w");
                 B.condBr(same, lSame, lWrap);
                 B.startBlock(lSame);
                 host.declare(`declare ptr @scr_closure_retain_v(ptr)`);
@@ -1347,14 +1409,14 @@ export class LlDyn {
                 host.declare(`declare void @scr_dyn_release_v(ptr)`);
                 const a = B.tmp();
                 B.line(`${a} = call ptr @scr_closure_new(ptr @${adapter}, ${host.sizeType} 1)`);
-                const sourceClosure = this.payloadOf(B, "%d", "ptr");
-                const sourceKind = B.tmp();
+                host.declare(`declare i32 @scr_dyn_function_kind(ptr)`);
                 const functionKind = B.tmp();
                 const targetKind = B.tmp();
-                B.line(`${sourceKind} = getelementptr inbounds %ScrClosure, ptr ${sourceClosure}, i64 0, i32 4`);
-                B.line(`${functionKind} = load i32, ptr ${sourceKind}`);
+                B.line(`${functionKind} = call i32 @scr_dyn_function_kind(ptr %d)`);
                 B.line(`${targetKind} = getelementptr inbounds %ScrClosure, ptr ${a}, i64 0, i32 4`);
-                B.line(`store i32 ${functionKind}, ptr ${targetKind}`);
+                const adapterKind = B.tmp();
+                B.line(`${adapterKind} = or i32 ${functionKind}, 8 ; preserves the checked callable in caps[0]`);
+                B.line(`store i32 ${adapterKind}, ptr ${targetKind}`);
                 const box = B.tmp();
                 B.line(`${box} = call ptr @scr_box_new_obj(ptr @scr_dyn_retain_v, ptr @scr_dyn_release_v, ptr @scr_dyn_trace_v)`);
                 const capp = B.tmp();
@@ -1690,9 +1752,19 @@ export class LlDyn {
                     const state = B.tmp();
                     const undefinedState = B.tmp();
                     const undefinedLabel = B.newLabel("tda.undefined");
+                    const holeLabel = B.newLabel("tda.hole");
+                    const presentLabel = B.newLabel("tda.present");
                     const valueLabel = B.newLabel("tda.value");
                     const doneLabel = B.newLabel("tda.done");
                     B.line(`${state} = call double @scr_arr_state(ptr %v, double ${i})`);
+                    const hole = B.tmp();
+                    B.line(`${hole} = fcmp oeq double ${state}, 0.0`); // SCR_ARR_HOLE
+                    B.condBr(hole, holeLabel, presentLabel);
+                    B.startBlock(holeLabel);
+                    host.declare(`declare void @scr_dyn_arr_push_hole(ptr)`);
+                    B.line(`call void @scr_dyn_arr_push_hole(ptr ${d})`);
+                    B.br(doneLabel);
+                    B.startBlock(presentLabel);
                     B.line(`${undefinedState} = fcmp oeq double ${state}, 2.0`); // SCR_ARR_UNDEFINED
                     B.terminate(`br i1 ${undefinedState}, label %${undefinedLabel}, label %${valueLabel}`);
                     B.startBlock(undefinedLabel);