@scriptc/cli-darwin-x64 0.2.0 → 0.2.2

package/dist/THIRD_PARTY_NOTICES

@@ -1,4 +1,4 @@
-scriptc 0.2.0 includes the existing TypeScript 7.0.2, LLVM, and C runtime dependencies.
+scriptc 0.2.2 includes the existing TypeScript 7.0.2, LLVM, and C runtime dependencies.
 TypeScript licensing: lib/typescript/LICENSE and lib/typescript/NOTICE.txt.
 LLVM licensing and notices: lib/llvm/LICENSE and lib/llvm/THIRD_PARTY_NOTICES.
 Runtime dependency licenses: lib/runtime-sources/vendor/*/LICENSE*.

package/dist/bin/scriptc.json

@@ -1,6 +1,6 @@
 {
   "schema": "scriptc.native-toolchain.v1",
-  "compiler_version": "0.2.0",
+  "compiler_version": "0.2.2",
   "target": "macos-x64",
   "ts7": "../lib/typescript/lib/tsc",
   "llvm_package": "../lib/llvm",

package/dist/lib/declarations/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[];
@@ -751,8 +752,7 @@ declare var ReadableStream: {
  * unknown — the same dynamic boundary as JSON.parse: cast and validate. */
 /* Headers — a response's native header map (lowercase names,
  * combine-on-append, sorted iteration). The value is a checked-dynamic
- * native handle like Response itself; constructing one statically
- * (`new Headers()`) keeps the constructor fence. */
+ * native handle like Response itself. */
 interface Headers {
   append(name: string, value: string): void;
   delete(name: string): void;
@@ -767,7 +767,7 @@ interface Headers {
   [Symbol.iterator](): IterableIterator<[string, string]>;
 }
 declare var Headers: {
-  new (init?: Record<string, string> | readonly (readonly [string, string])[]): Headers;
+  new (init?: Headers | Record<string, string> | readonly (readonly [string, string])[]): Headers;
   readonly prototype: Headers;
 };
 interface Response {
@@ -810,6 +810,18 @@ interface Request {
   readonly method: string;
   readonly url: string;
   readonly headers: Headers;
+  readonly destination: string;
+  readonly referrer: string;
+  readonly referrerPolicy: string;
+  readonly mode: string;
+  readonly credentials: string;
+  readonly cache: string;
+  readonly redirect: "follow" | "error" | "manual";
+  readonly integrity: string;
+  readonly keepalive: boolean;
+  readonly isReloadNavigation: boolean;
+  readonly isHistoryNavigation: boolean;
+  readonly duplex: "half";
   readonly signal: AbortSignal;
   readonly body: ReadableStream<Uint8Array> | null;
   readonly bodyUsed: boolean;
@@ -1059,14 +1071,12 @@ declare module "node:fs" {
   export function readFileSync(fd: number): Buffer;
   /* The options-object spelling of the utf8 form. */
   export function readFileSync(path: string, options: { encoding: "utf8" | "utf-8" }): string;
-  /* Error-first callback target used by the static util.promisify
-   * projection. Its options stay unknown because direct calls remain
-   * outside the typed fs slice; this also lets checked-JS validation
-   * ladders observe invalid runtime encodings without contextual narrowing. */
+  /* Error-first callbacks select string or Buffer data from their encoding.
+   * Unknown options retain that union until the caller validates the value. */
   export function readFile(
     path: string,
     options: unknown,
-    callback: (error: Error | null, data: string) => void,
+    callback: (error: Error | null, data: string | Buffer) => void,
   ): void;
   /* The options form carries the mode (applied at CREATION only, like
    * Node — an existing file keeps its permissions) and/or the utf8
@@ -1163,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. */
@@ -1256,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,
@@ -1271,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>;
@@ -1429,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
@@ -1455,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.
@@ -1490,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;
 }
@@ -1497,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;
@@ -1522,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
@@ -1678,6 +1738,9 @@ declare module "child_process" {
   }
 
   export interface ChildProcess extends Disposable {
+    ref(): void;
+    on(event: "spawn", listener: () => void): void;
+    once(event: "spawn", listener: () => void): void;
     /* The exit listener may also take Node's second parameter — the
      * terminating signal's name, null for a normal exit. */
     on(event: "exit", listener: (code: number | null, signal: string | null) => void): void;
@@ -1715,16 +1778,13 @@ declare module "child_process" {
     readonly stdout: NodeJS.ReadableStream | null;
     readonly stderr: NodeJS.ReadableStream | null;
   }
-  export function spawn(
-    command: string,
-    args?: string[],
-    options?: {
+  export interface SpawnOptions {
       /* The 3-tuple form admits number fds in the stdout/stderr slots —
        * openSync results dup2'd into the child (the daemon-log idiom
        * ["ignore", logFd, logFd]) — and "pipe" there too (child.stdout/
        * child.stderr streams); "pipe" in the stdin slot exposes
        * child.stdin. */
-      stdio: "ignore" | "inherit" | "pipe" | ("ignore" | "inherit" | "pipe" | number)[];
+      stdio?: "ignore" | "inherit" | "pipe" | ("ignore" | "inherit" | "pipe" | number)[];
       /* detached gives the child its own session and process group
        * (POSIX_SPAWN_SETSID); env REPLACES the child environment; cwd
        * sets its working directory; windowsHide is a POSIX no-op; shell
@@ -1734,8 +1794,9 @@ declare module "child_process" {
       cwd?: string;
       windowsHide?: boolean;
       shell?: boolean;
-    },
-  ): ChildProcess;
+  }
+  export function spawn(command: string, args?: string[], options?: SpawnOptions): ChildProcess;
+  export function spawn(command: string, options?: SpawnOptions): ChildProcess;
 
   export function fork(
     modulePath: string | URL,
@@ -1822,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;
@@ -3387,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/lib/llvm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/llvm-darwin-x64",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Pinned LLVM code-generation helper for scriptc on macOS x64",
   "license": "Apache-2.0 WITH LLVM-exception",
   "homepage": "https://scriptc.dev",