@scriptc/compiler 0.3.5 → 0.3.6

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

@@ -299,7 +299,7 @@ declare var process: {
   stdout: import("tty").WriteStream;
   stderr: import("tty").WriteStream;
   /* The stdin stream, the piped-input slice: the TTY probe, the
-   * data/end/error events (on and once — a 'data' listener keeps the
+   * data/end/error events and readline's 'keypress' (on and once — a 'data' listener keeps the
    * event loop alive until EOF, like Node's flowing stdin), destroy()
    * (full teardown: nothing fires after, the loop stops waiting), and
    * async iteration (`for await (const chunk of process.stdin)` — chunks
@@ -310,9 +310,18 @@ declare var process: {
     on(event: "data", listener: (chunk: Uint8Array) => void): void;
     on(event: "end", listener: () => void): void;
     on(event: "error", listener: (err: Error) => void): void;
+    /* readline.emitKeypressEvents(process.stdin)'s keys */
+    on(
+      event: "keypress",
+      listener: (str: string | undefined, key: import("readline").Key) => void,
+    ): void;
     once(event: "data", listener: (chunk: Uint8Array) => void): void;
     once(event: "end", listener: () => void): void;
     once(event: "error", listener: (err: Error) => void): void;
+    once(
+      event: "keypress",
+      listener: (str: string | undefined, key: import("readline").Key) => void,
+    ): void;
     destroy(): void;
     setEncoding(encoding: "utf8"): void;
     /* Termios raw mode on a TTY stdin (libuv's UV_TTY_MODE_RAW, the mode
@@ -1251,6 +1260,45 @@ declare module "node:fs" {
     path: string | Uint8Array | URL,
     type?: string | null,
   ): void;
+  /* fs.cpSync / fs.cp: copies a file, symlink or (with recursive) a
+   * directory tree. filter decides per path; the callback and promise
+   * forms complete the copy before reporting. */
+  export interface CopySyncOptions {
+    dereference?: boolean;
+    errorOnExist?: boolean;
+    filter?: (source: string, destination: string) => boolean;
+    force?: boolean;
+    mode?: number;
+    preserveTimestamps?: boolean;
+    recursive?: boolean;
+    verbatimSymlinks?: boolean;
+  }
+  export interface CopyOptions {
+    dereference?: boolean;
+    errorOnExist?: boolean;
+    filter?: (source: string, destination: string) => boolean | Promise<boolean>;
+    force?: boolean;
+    mode?: number;
+    preserveTimestamps?: boolean;
+    recursive?: boolean;
+    verbatimSymlinks?: boolean;
+  }
+  export function cpSync(
+    source: string | URL,
+    destination: string | URL,
+    options?: CopySyncOptions,
+  ): void;
+  export function cp(
+    source: string | URL,
+    destination: string | URL,
+    callback: (err: NodeJS.ErrnoException | null) => void,
+  ): void;
+  export function cp(
+    source: string | URL,
+    destination: string | URL,
+    options: CopyOptions,
+    callback: (err: NodeJS.ErrnoException | null) => void,
+  ): void;
   export function symlink(
     target: string | Uint8Array | URL,
     path: string | Uint8Array | URL,
@@ -1441,6 +1489,9 @@ declare module "node:fs" {
     readonly O_NONBLOCK: number;
     readonly O_TRUNC: number;
     readonly O_APPEND: number;
+    readonly COPYFILE_EXCL: number;
+    readonly COPYFILE_FICLONE: number;
+    readonly COPYFILE_FICLONE_FORCE: number;
   };
   /* A stat(2) snapshot (statSync follows symlinks, lstatSync does not —
    * Node's split) — immutable; the supported surface is exactly these
@@ -1474,8 +1525,37 @@ declare module "node:fs" {
     readonly ctime: Date;
     readonly birthtime: Date;
   }
-  export function statSync(path: string): Stats;
-  export function lstatSync(path: string): Stats;
+  /* throwIfNoEntry: false answers undefined for a missing entry (ENOENT or
+   * ENOTDIR) instead of throwing. BigIntStats (bigint: true) has no
+   * lowering. */
+  export interface StatSyncOptions {
+    bigint?: boolean;
+    throwIfNoEntry?: boolean;
+  }
+  export function statSync(path: string, options?: undefined): Stats;
+  export function statSync(
+    path: string,
+    options: StatSyncOptions & { bigint?: false; throwIfNoEntry: false },
+  ): Stats | undefined;
+  export function statSync(
+    path: string,
+    options: StatSyncOptions & { bigint?: false; throwIfNoEntry?: true },
+  ): Stats;
+  /* bigint: true type-checks so the lowering can name it as unsupported. */
+  export function statSync(path: string, options: StatSyncOptions & { bigint: true }): Stats;
+  export function statSync(path: string, options: StatSyncOptions): Stats | undefined;
+  export function lstatSync(path: string, options?: undefined): Stats;
+  export function lstatSync(
+    path: string,
+    options: StatSyncOptions & { bigint?: false; throwIfNoEntry: false },
+  ): Stats | undefined;
+  export function lstatSync(
+    path: string,
+    options: StatSyncOptions & { bigint?: false; throwIfNoEntry?: true },
+  ): Stats;
+  /* bigint: true type-checks so the lowering can name it as unsupported. */
+  export function lstatSync(path: string, options: StatSyncOptions & { bigint: true }): Stats;
+  export function lstatSync(path: string, options: StatSyncOptions): Stats | undefined;
   /* The fd pair behind spawn's fd-stdio form: openSync(path, flags) →
    * the raw fd. Numeric flags use an inline OR of the O_* constants. */
   export function openSync(path: string, flags: string): number;
@@ -1760,6 +1840,11 @@ declare module "fs/promises" {
     path: string | Uint8Array | URL,
     type?: string | null,
   ): Promise<void>;
+  export function cp(
+    source: string | URL,
+    destination: string | URL,
+    options?: import("node:fs").CopyOptions,
+  ): Promise<void>;
   export function readlink(
     path: string | Uint8Array | URL,
     options: "buffer" | { encoding: "buffer" },
@@ -2376,6 +2461,7 @@ declare module "node:url" {
 
 /* node:crypto: the static hashing/MAC/random/key-derivation utility slice. */
 declare module "crypto" {
+  import { Transform } from "stream";
   export type KeyObjectType = "secret" | "public" | "private";
   export interface JsonWebKey {
     kty?: string;
@@ -2418,14 +2504,16 @@ declare module "crypto" {
   export interface HashOptions {
     outputLength?: number | undefined;
   }
-  export interface Hash {
+  /* Hash and Hmac are Transforms: written chunks update the digest, which
+   * the readable side delivers once the writable side ends. */
+  export interface Hash extends Transform {
     copy(options?: HashOptions): Hash;
     update(data: string | ArrayBufferView): Hash;
     update(data: string, inputEncoding: Encoding): Hash;
     digest(): Buffer;
     digest(encoding: BinaryToTextEncoding): string;
   }
-  export interface Hmac {
+  export interface Hmac extends Transform {
     update(data: string | ArrayBufferView): Hmac;
     update(data: string, inputEncoding: Encoding): Hmac;
     digest(): Buffer;
@@ -3033,6 +3121,12 @@ declare module "util" {
   export type TextDecoder = globalThis.TextDecoder;
   export var TextEncoder: typeof globalThis.TextEncoder;
   export var TextDecoder: typeof globalThis.TextDecoder;
+  /* stream.pipeline's (...streams: unknown[]) => unknown is assignable to
+   * every other target's parameter type, so its overload comes first; no
+   * other target is assignable to it. */
+  export function promisify(
+    fn: typeof import("node:stream").pipeline,
+  ): typeof import("node:stream/promises").pipeline;
   export function promisify(
     fn: typeof import("node:fs").readFile,
   ): (path: string, encoding: "utf8" | "utf-8") => Promise<string>;
@@ -3051,6 +3145,12 @@ declare module "util" {
       windowsHide?: boolean;
     },
   ) => Promise<{ stdout: string; stderr: string }>;
+  export function promisify(
+    fn: typeof globalThis.setTimeout,
+  ): typeof import("node:timers/promises").setTimeout;
+  export function promisify(
+    fn: typeof globalThis.setImmediate,
+  ): typeof import("node:timers/promises").setImmediate;
   export function promisify(fn: typeof import("node:child_process").exec): (
     command: string,
     options?: {
@@ -3063,6 +3163,14 @@ declare module "util" {
       windowsHide?: boolean;
     },
   ) => Promise<{ stdout: string; stderr: string }>;
+  /* The zlib callback one-shots (deflate, inflate, deflateRaw, inflateRaw,
+   * gzip, gunzip, unzip) share one type. */
+  export function promisify(
+    fn: typeof import("node:zlib").gzip,
+  ): (data: string | Uint8Array, options?: import("node:zlib").ZlibOptions) => Promise<Buffer>;
+  export function promisify(
+    fn: typeof import("node:stream").finished,
+  ): typeof import("node:stream/promises").finished;
   /* Declared surface without full lowering (the type-level tolerance
    * story: guarded/diagnostic-path code must TYPECHECK; a reached use
    * without a lowering fences at its site). inspect's options carry the
@@ -3249,8 +3357,9 @@ declare module "node:test" {
   function after(fn: HookFn): void;
   function beforeEach(fn: HookFn): void;
   function afterEach(fn: HookFn): void;
-  /* The mock function surface: mock.fn and t.mock.fn, with the calls log
-   * and the implementation controls on fn.mock. */
+  /* The mock function surface: mock.fn, mock.method and their t.mock
+   * twins, the tracker's restoreAll and reset, and the calls log and the
+   * implementation controls on fn.mock. */
   interface MockFunctionCall<
     F extends Function,
     ReturnType = F extends (...args: any) => infer T ? T : unknown,
@@ -3270,17 +3379,35 @@ declare module "node:test" {
     restore(): void;
   }
   type Mock<F extends Function> = F & { mock: MockFunctionContext<F> };
+  interface MockFunctionOptions {
+    times?: number;
+  }
+  type FunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends Function ? K : never;
+  }[keyof T];
   interface MockTracker {
     fn<F extends Function = (...args: any[]) => undefined>(original?: F): Mock<F>;
     fn<F extends Function = (...args: any[]) => undefined, Implementation extends Function = F>(
       original?: F,
       implementation?: Implementation,
     ): Mock<F | Implementation>;
-    method<MockedObject extends object>(
+    method<MockedObject extends object, MethodName extends FunctionPropertyNames<MockedObject>>(
       object: MockedObject,
-      methodName: keyof MockedObject,
-      implementation?: Function,
-    ): Mock<Function>;
+      methodName: MethodName,
+      options?: MockFunctionOptions,
+    ): MockedObject[MethodName] extends Function ? Mock<MockedObject[MethodName]> : never;
+    method<
+      MockedObject extends object,
+      MethodName extends FunctionPropertyNames<MockedObject>,
+      Implementation extends Function,
+    >(
+      object: MockedObject,
+      methodName: MethodName,
+      implementation: Implementation,
+      options?: MockFunctionOptions,
+    ): MockedObject[MethodName] extends Function
+      ? Mock<MockedObject[MethodName] | Implementation>
+      : never;
     reset(): void;
     restoreAll(): void;
   }
@@ -3523,10 +3650,31 @@ declare module "node:querystring" {
  * on("close", cb). An open interface keeps the process alive until
  * close()/EOF, Node's semantics; lines split on \n and \r\n. */
 declare module "readline" {
-  /* The non-terminal Interface over process.stdin or a stream input
-   * (scr_readline.c). Listener registrations are statements: chaining
-   * on()/once() results has no lowering. */
+  /* The Interface over process.stdin or a stream input (scr_readline.c;
+   * terminal mode in scr_readline_tty.c). Listener registrations are
+   * statements: chaining on()/once() results has no lowering. */
+  export interface Key {
+    sequence?: string;
+    name?: string;
+    ctrl?: boolean;
+    meta?: boolean;
+    shift?: boolean;
+  }
   export interface Interface extends Disposable {
+    /* terminal says whether the interface edits lines as a terminal;
+     * line and cursor are the terminal's (line is '' otherwise). history
+     * is the history option itself (or the interface's own empty array);
+     * a terminal records the lines it reads. */
+    readonly terminal: boolean;
+    readonly line: string;
+    readonly cursor: number;
+    getCursorPos(): CursorPos;
+    history: string[];
+    readonly historySize: number;
+    readonly historyIndex: number;
+    readonly crlfDelay: number;
+    readonly tabSize: number;
+    readonly escapeCodeTimeout: number;
     question(query: string, callback: (answer: string) => void): void;
     close(): void;
     pause(): this;
@@ -3534,16 +3682,28 @@ declare module "readline" {
     prompt(preserveCursor?: boolean): void;
     setPrompt(prompt: string): void;
     getPrompt(): string;
-    write(data: string): void;
+    write(data: string | null | undefined, key?: Key): void;
     on(event: "line", listener: (input: string) => void): this;
-    on(event: "close" | "pause" | "resume", listener: () => void): this;
+    on(
+      event: "close" | "pause" | "resume" | "SIGINT" | "SIGTSTP" | "SIGCONT",
+      listener: () => void,
+    ): this;
     on(event: "error", listener: (err: Error) => void): this;
+    on(event: "history", listener: (history: string[]) => void): this;
     once(event: "line", listener: (input: string) => void): this;
-    once(event: "close" | "pause" | "resume", listener: () => void): this;
+    once(
+      event: "close" | "pause" | "resume" | "SIGINT" | "SIGTSTP" | "SIGCONT",
+      listener: () => void,
+    ): this;
     once(event: "error", listener: (err: Error) => void): this;
+    once(event: "history", listener: (history: string[]) => void): this;
     addListener(event: "line", listener: (input: string) => void): this;
-    addListener(event: "close" | "pause" | "resume", listener: () => void): this;
+    addListener(
+      event: "close" | "pause" | "resume" | "SIGINT" | "SIGTSTP" | "SIGCONT",
+      listener: () => void,
+    ): this;
     addListener(event: "error", listener: (err: Error) => void): this;
+    addListener(event: "history", listener: (history: string[]) => void): this;
     [Symbol.asyncIterator](): AsyncIterableIterator<string>;
     [Symbol.dispose](): void;
   }
@@ -3553,26 +3713,83 @@ declare module "readline" {
     terminal?: boolean;
     /* Node's crlfDelay: a \n arriving within this many ms (at least 100)
      * after a line ended by \r is dropped. completer and the history
-     * knobs fence by name (no interactive terminal). The options-record
+     * options are validated and kept; a terminal interface uses them.
+     * The options-record
      * stance (see http.RequestOptions) admits every key; the walk
      * decides. */
     crlfDelay?: number;
     completer?: unknown;
     signal?: AbortSignal;
+    history?: string[];
+    historySize?: number;
+    removeHistoryDuplicates?: boolean;
+    tabSize?: number;
+    escapeCodeTimeout?: number;
     [option: string]: unknown;
   }
   export function createInterface(options: ReadLineOptions): Interface;
-  export function createInterface(input: unknown, output?: unknown): Interface;
+  export function createInterface(
+    input: unknown,
+    output?: unknown,
+    completer?: unknown,
+    terminal?: boolean,
+  ): Interface;
+  export interface CursorPos {
+    rows: number;
+    cols: number;
+  }
+  /* The escape-sequence helpers over process.stdout, process.stderr, a
+   * writable stream, or null/undefined (nothing is written). */
+  export function cursorTo(stream: unknown, x: number, y?: number, callback?: () => void): boolean;
+  export function cursorTo(stream: unknown, x: number, callback: () => void): boolean;
+  export function moveCursor(
+    stream: unknown,
+    dx: number,
+    dy: number,
+    callback?: () => void,
+  ): boolean;
+  export function clearLine(stream: unknown, dir: -1 | 0 | 1, callback?: () => void): boolean;
+  export function clearScreenDown(stream: unknown, callback?: () => void): boolean;
+  /* 'keypress' events (str, key) on process.stdin or a readable stream */
+  export function emitKeypressEvents(stream: unknown, readlineInterface?: unknown): void;
+  /* the same object as node:readline/promises */
+  export const promises: typeof import("node:readline/promises");
 }
 declare module "node:readline" {
   export * from "readline";
 }
 declare module "readline/promises" {
-  import { ReadLineOptions } from "readline";
+  import { CursorPos, Key, ReadLineOptions } from "readline";
+  /* The escape-sequence builder over process.stdout, process.stderr or a
+   * writable stream: actions queue until commit(), or are written on the
+   * next tick with autoCommit. */
+  export class Readline {
+    constructor(stream: unknown, options?: { autoCommit?: boolean });
+    clearLine(dir: -1 | 0 | 1): this;
+    clearScreenDown(): this;
+    commit(): Promise<void>;
+    cursorTo(x: number, y?: number): this;
+    moveCursor(dx: number, dy: number): this;
+    rollback(): this;
+  }
   /* The readline Interface with the promise question: it resolves with
    * the next line, rejects with an AbortError when options.signal aborts,
    * and with ERR_USE_AFTER_CLOSE after close(). */
   export interface Interface extends Disposable {
+    /* terminal says whether the interface edits lines as a terminal;
+     * line and cursor are the terminal's (line is '' otherwise). history
+     * is the history option itself (or the interface's own empty array);
+     * a terminal records the lines it reads. */
+    readonly terminal: boolean;
+    readonly line: string;
+    readonly cursor: number;
+    getCursorPos(): CursorPos;
+    history: string[];
+    readonly historySize: number;
+    readonly historyIndex: number;
+    readonly crlfDelay: number;
+    readonly tabSize: number;
+    readonly escapeCodeTimeout: number;
     question(query: string, options?: { signal?: AbortSignal }): Promise<string>;
     close(): void;
     pause(): this;
@@ -3580,21 +3797,38 @@ declare module "readline/promises" {
     prompt(preserveCursor?: boolean): void;
     setPrompt(prompt: string): void;
     getPrompt(): string;
-    write(data: string): void;
+    write(data: string | null | undefined, key?: Key): void;
     on(event: "line", listener: (input: string) => void): this;
-    on(event: "close" | "pause" | "resume", listener: () => void): this;
+    on(
+      event: "close" | "pause" | "resume" | "SIGINT" | "SIGTSTP" | "SIGCONT",
+      listener: () => void,
+    ): this;
     on(event: "error", listener: (err: Error) => void): this;
+    on(event: "history", listener: (history: string[]) => void): this;
     once(event: "line", listener: (input: string) => void): this;
-    once(event: "close" | "pause" | "resume", listener: () => void): this;
+    once(
+      event: "close" | "pause" | "resume" | "SIGINT" | "SIGTSTP" | "SIGCONT",
+      listener: () => void,
+    ): this;
     once(event: "error", listener: (err: Error) => void): this;
+    once(event: "history", listener: (history: string[]) => void): this;
     addListener(event: "line", listener: (input: string) => void): this;
-    addListener(event: "close" | "pause" | "resume", listener: () => void): this;
+    addListener(
+      event: "close" | "pause" | "resume" | "SIGINT" | "SIGTSTP" | "SIGCONT",
+      listener: () => void,
+    ): this;
     addListener(event: "error", listener: (err: Error) => void): this;
+    addListener(event: "history", listener: (history: string[]) => void): this;
     [Symbol.asyncIterator](): AsyncIterableIterator<string>;
     [Symbol.dispose](): void;
   }
   export function createInterface(options: ReadLineOptions): Interface;
-  export function createInterface(input: unknown, output?: unknown): Interface;
+  export function createInterface(
+    input: unknown,
+    output?: unknown,
+    completer?: unknown,
+    terminal?: boolean,
+  ): Interface;
 }
 declare module "node:readline/promises" {
   export * from "readline/promises";
@@ -4161,7 +4395,7 @@ declare module "net" {
     /* http.createServer(handler)'s event twin (a no-parser net server
      * never fires it, like Node). */
     on(
-      event: "request",
+      event: "request" | "checkContinue" | "checkExpectation",
       listener: (req: import("http").IncomingMessage, res: import("http").ServerResponse) => void,
     ): void;
     /* addListener IS on (Node aliases them) — the suite spells both. */
@@ -4175,7 +4409,7 @@ declare module "net" {
       listener: (req: import("http").IncomingMessage, socket: Socket, head: Buffer) => void,
     ): void;
     addListener(
-      event: "request",
+      event: "request" | "checkContinue" | "checkExpectation",
       listener: (req: import("http").IncomingMessage, res: import("http").ServerResponse) => void,
     ): void;
     once(event: "connection" | "secureConnection", listener: (socket: Socket) => void): void;
@@ -4188,7 +4422,7 @@ declare module "net" {
       listener: (req: import("http").IncomingMessage, socket: Socket, head: Buffer) => void,
     ): void;
     once(
-      event: "request",
+      event: "request" | "checkContinue" | "checkExpectation",
       listener: (req: import("http").IncomingMessage, res: import("http").ServerResponse) => void,
     ): void;
   }
@@ -4309,6 +4543,7 @@ declare module "http" {
     requireHostHeader?: boolean;
     joinDuplicateHeaders?: boolean;
     keepAliveTimeoutBuffer?: number;
+    maxHeaderSize?: number;
     [option: string]: unknown;
   }
   /* The outgoing-header shape, @types/node's matrix: numbers format via
@@ -4428,6 +4663,8 @@ declare module "http" {
      * Agent VALUE threads through (getName-keyed maxSockets accounting
      * over one-dial-per-request connections). */
     agent?: Agent | boolean | null;
+    /* Aborting destroys the request with an AbortError. */
+    signal?: AbortSignal;
     /* The options-record stance: Node ignores an options record's
      * unknown keys, so every key typechecks here — the option WALK in
      * the lowering decides per key (lower, fence by name, or drop
@@ -4509,7 +4746,7 @@ declare module "http" {
     setTimeout(timeout: number, callback?: () => void): this;
     write(data: string | Uint8Array): void;
     end(data?: string | Uint8Array): void;
-    destroy(): void;
+    destroy(error?: Error): void;
     abort(): void;
     on(event: "response", listener: (res: IncomingMessage) => void): void;
     on(event: "socket", listener: (socket: Socket) => void): void;
@@ -4517,7 +4754,7 @@ declare module "http" {
       event: "upgrade",
       listener: (res: IncomingMessage, socket: Socket, head: Buffer) => void,
     ): void;
-    on(event: "timeout" | "close" | "finish" | "abort", listener: () => void): void;
+    on(event: "timeout" | "close" | "finish" | "abort" | "continue", listener: () => void): void;
     on(event: "error", listener: (err: Error) => void): void;
     /* addListener IS on (Node aliases them) — the suite spells both. */
     addListener(event: "response", listener: (res: IncomingMessage) => void): void;
@@ -4534,7 +4771,7 @@ declare module "http" {
       event: "upgrade",
       listener: (res: IncomingMessage, socket: Socket, head: Buffer) => void,
     ): void;
-    once(event: "timeout" | "close" | "finish" | "abort", listener: () => void): void;
+    once(event: "timeout" | "close" | "finish" | "abort" | "continue", listener: () => void): void;
     once(event: "error", listener: (err: Error) => void): void;
   }
   export function createServer(
@@ -4697,6 +4934,8 @@ declare module "https" {
     rejectUnauthorized?: boolean;
     ca?: string | Uint8Array;
     agent?: Agent | boolean | null;
+    /* Aborting destroys the request with an AbortError. */
+    signal?: AbortSignal;
     /* The options-record stance (see http.RequestOptions). */
     [option: string]: unknown;
   }
@@ -5572,6 +5811,13 @@ declare module "worker_threads" {
     removeAllListeners(event?: string): this;
     listenerCount(event: string, listener?: (...args: any[]) => void): number;
   }
+  /* Two entangled ports; a port moves to another thread through a
+   * postMessage or workerData transferList. */
+  export class MessageChannel {
+    readonly port1: MessagePort;
+    readonly port2: MessagePort;
+  }
+  export function receiveMessageOnPort(port: MessagePort): { message: any } | undefined;
   export const parentPort: MessagePort | null;
   export const workerData: any;
 }

package/dist/backend/llvm/dyn.js

@@ -9,7 +9,7 @@ import { dynDesc, streamTypedRefEligible } from "../../ir/analysis.js";
 import { mangleRecordNew, mangleRecordStruct } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
 import { llvmCommentText } from "./common.js";
-import { arrNewCall, elemAccess, llFieldType, releaseSym, traceAdapter, traceArg, vAdapters, } from "./shapes.js";
+import { arrNewCall, elemAccess, llFieldType, mapFlagsOffset, releaseSym, traceAdapter, traceArg, vAdapters, } from "./shapes.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
 import { recordMayKeepSource, recordSourceFieldOrder } from "./record-sources.js";
 /** Whether to-dyn of a record shape keeps the record itself: an empty shape
@@ -1570,6 +1570,17 @@ export class LlDyn {
                     const ovf = B.tmp();
                     B.line(`${ovfp} = getelementptr inbounds %${struct}, ptr %r0, i64 0, i32 ${shape.fields.length + 1}`);
                     B.line(`${ovf} = load ptr, ptr ${ovfp} ; overflow map`);
+                    if (shape.fields.length === 0) {
+                        // Object.create(null)'s dictionary keeps its null prototype:
+                        // ScrDyn.null_proto becomes SCR_MAP_NULL_PROTO.
+                        const npp = B.tmp();
+                        const np = B.tmp();
+                        const flagsp = B.tmp();
+                        B.line(`${npp} = getelementptr inbounds i8, ptr %d, i64 ${this.abiOffset(13, 9)} ; ->null_proto`);
+                        B.line(`${np} = load i8, ptr ${npp}`);
+                        B.line(`${flagsp} = getelementptr inbounds i8, ptr ${ovf}, i64 ${mapFlagsOffset(host.sizeType)}`);
+                        B.line(`store i8 ${np}, ptr ${flagsp}`);
+                    }
                     const n = this.lenOf(B, "%d");
                     const entries = this.itemsOf(B, "%d");
                     this.i64Loop(B, "dcv", n, (i, brNext) => {
@@ -2130,6 +2141,25 @@ export class LlDyn {
                     host.declare(`declare ptr @scr_dyn_new_obj_with_identity(ptr, ptr, ptr)`);
                     B.line(`${d} = call ptr @scr_dyn_new_obj_with_identity(ptr %v, ptr ${rc.retain}, ptr @${sourceAccessor.name})`);
                 }
+                else if (shape.indexValue && shape.fields.length === 0) {
+                    // A pure index-signature record keeps a null prototype
+                    // (SCR_MAP_NULL_PROTO on its overflow map; Object.groupBy).
+                    host.declare(`declare ptr @scr_dyn_new_obj()`);
+                    host.declare(`declare ptr @scr_dyn_new_obj_null_proto()`);
+                    const ovfp = B.tmp();
+                    const ovf = B.tmp();
+                    const flagsp = B.tmp();
+                    const flags = B.tmp();
+                    const np = B.tmp();
+                    const alloc = B.tmp();
+                    B.line(`${ovfp} = getelementptr inbounds %${struct}, ptr %v, i64 0, i32 1`);
+                    B.line(`${ovf} = load ptr, ptr ${ovfp} ; overflow map`);
+                    B.line(`${flagsp} = getelementptr inbounds i8, ptr ${ovf}, i64 ${mapFlagsOffset(host.sizeType)}`);
+                    B.line(`${flags} = load i8, ptr ${flagsp}`);
+                    B.line(`${np} = icmp ne i8 ${flags}, 0`);
+                    B.line(`${alloc} = select i1 ${np}, ptr @scr_dyn_new_obj_null_proto, ptr @scr_dyn_new_obj`);
+                    B.line(`${d} = call ptr ${alloc}()`);
+                }
                 else {
                     host.declare(`declare ptr @scr_dyn_new_obj()`);
                     B.line(`${d} = call ptr @scr_dyn_new_obj()`);