sci2-ts 0.0.0-stage → 0.2.1

package/packages/sci/src/text/message.d.ts

@@ -0,0 +1,69 @@
+/**
+ * A message is addressed by (noun, verb, condition, sequence), all scoped to a room/module
+ * number (the resource number):
+ *   noun      the thing involved (an object, a character, the room itself)
+ *   verb      what the player did to it (look, do, talk, use an inventory item...)
+ *   condition a game-state variant (e.g. day vs night, class, puzzle solved)
+ *   sequence  1, 2, 3... for multi-line exchanges
+ */
+export interface MessageTuple {
+    noun: number;
+    verb: number;
+    cond: number;
+    seq: number;
+}
+export interface MessageRecord extends MessageTuple {
+    /** Who says it. Talker ids are defined by the game scripts (e.g. 99 narrator, 97 hero). */
+    talker: number;
+    text: string;
+    /** Another message to use instead of this one. See `hasRef`. */
+    ref: MessageTuple;
+}
+export interface MessageFile {
+    version: number;
+    records: MessageRecord[];
+    /**
+     * Bytes after the strings, kept only so files round-trip: the engine never reads them.
+     * `trailerCount` is the header's entry count; the entries look like editor bookkeeping
+     * (many start with a 4-byte timestamp) and aren't fixed-size.
+     */
+    trailer?: Uint8Array;
+    trailerCount?: number;
+}
+/**
+ * SCI1.1/SCI32 message resource (versions 4000–5000 share this layout):
+ *
+ *   +0 u32 version
+ *   +4 u16 end of the strings, counted from +6   +6 u16 trailer entry count
+ *   +8 u16 record count
+ *   +10 records, 11 bytes each:
+ *       noun, verb, cond, seq, talker, u16 string offset, refNoun, refVerb, refCond, refSeq
+ *   NUL-terminated Latin-1 strings, one per record, in record order
+ *   trailer (unused by the engine; editor bookkeeping)
+ *
+ * Measured on all 152 message files of an SCI2 game (versions 4210, 4321, 4341, 5000): no gaps, no
+ * shared strings, so `writeMessages` reproduces them byte for byte.
+ */
+export declare function parseMessages(data: Uint8Array): MessageFile;
+/** The binary resource for a message file (the inverse of `parseMessages`). */
+export declare function writeMessages(file: MessageFile): Uint8Array;
+/**
+ * Message files as text, one record per line, for editing and mods:
+ *
+ *   messages 770 version 4321
+ *   ; noun verb cond seq talker "text"  [-> noun verb cond seq]
+ *   4 1 0 1 99 "You see an old stone altar."
+ *   5 1 0 1 99 "" -> 4 1 0 1
+ *   trailer 134 005e7c962c2c0000...
+ *
+ * `labels` can annotate lines with comments (e.g. verb names), which parsing ignores.
+ */
+export declare function messagesToText(number: number, file: MessageFile, labels?: (r: MessageRecord) => string | undefined): string;
+export declare function messagesFromText(text: string): {
+    number: number;
+    file: MessageFile;
+};
+/** Noun 0 means "the room itself", so a reference is any non-zero noun, verb or condition. */
+export declare const hasRef: (r: MessageRecord) => boolean;
+/** Finds a message, following references (bounded, in case of cycles). */
+export declare function findMessage(file: MessageFile, tuple: MessageTuple): MessageRecord | undefined;

package/packages/sci/src/text/message.js

@@ -0,0 +1,171 @@
+/**
+ * SCI1.1/SCI32 message resource (versions 4000–5000 share this layout):
+ *
+ *   +0 u32 version
+ *   +4 u16 end of the strings, counted from +6   +6 u16 trailer entry count
+ *   +8 u16 record count
+ *   +10 records, 11 bytes each:
+ *       noun, verb, cond, seq, talker, u16 string offset, refNoun, refVerb, refCond, refSeq
+ *   NUL-terminated Latin-1 strings, one per record, in record order
+ *   trailer (unused by the engine; editor bookkeeping)
+ *
+ * Measured on all 152 message files of an SCI2 game (versions 4210, 4321, 4341, 5000): no gaps, no
+ * shared strings, so `writeMessages` reproduces them byte for byte.
+ */
+export function parseMessages(data) {
+    const v = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const version = v.getUint32(0, true);
+    if (version < 4000)
+        throw new Error(`Message version ${version} not supported`);
+    const decoder = new TextDecoder("latin1");
+    const count = v.getUint16(8, true);
+    const records = [];
+    let stringsEnd = 10 + count * 11;
+    for (let i = 0; i < count; i++) {
+        const r = 10 + i * 11;
+        const start = v.getUint16(r + 5, true);
+        let end = start;
+        while (end < data.length && data[end] !== 0)
+            end++;
+        stringsEnd = Math.max(stringsEnd, end + 1);
+        records.push({
+            noun: data[r],
+            verb: data[r + 1],
+            cond: data[r + 2],
+            seq: data[r + 3],
+            talker: data[r + 4],
+            text: decoder.decode(data.subarray(start, end)),
+            ref: { noun: data[r + 7], verb: data[r + 8], cond: data[r + 9], seq: data[r + 10] },
+        });
+    }
+    return { version, records, trailer: data.slice(stringsEnd), trailerCount: v.getUint16(6, true) };
+}
+const encoder = (text) => Uint8Array.from(text, (c) => c.charCodeAt(0) & 0xff);
+/** The binary resource for a message file (the inverse of `parseMessages`). */
+export function writeMessages(file) {
+    const strings = file.records.map((r) => encoder(r.text));
+    const recordsEnd = 10 + file.records.length * 11;
+    const stringsEnd = recordsEnd + strings.reduce((n, s) => n + s.length + 1, 0);
+    const trailer = file.trailer ?? new Uint8Array(0);
+    const out = new Uint8Array(stringsEnd + trailer.length);
+    const v = new DataView(out.buffer);
+    v.setUint32(0, file.version, true);
+    v.setUint16(4, stringsEnd - 6, true);
+    v.setUint16(6, file.trailerCount ?? 0, true);
+    v.setUint16(8, file.records.length, true);
+    let at = recordsEnd;
+    file.records.forEach((r, i) => {
+        const o = 10 + i * 11;
+        out.set([r.noun, r.verb, r.cond, r.seq, r.talker], o);
+        v.setUint16(o + 5, at, true);
+        out.set([r.ref.noun, r.ref.verb, r.ref.cond, r.ref.seq], o + 7);
+        out.set(strings[i], at);
+        at += strings[i].length + 1;
+    });
+    if (stringsEnd > 0xffff)
+        throw new Error("Message file too large (string offsets are 16-bit)");
+    out.set(trailer, stringsEnd);
+    return out;
+}
+/**
+ * Message files as text, one record per line, for editing and mods:
+ *
+ *   messages 770 version 4321
+ *   ; noun verb cond seq talker "text"  [-> noun verb cond seq]
+ *   4 1 0 1 99 "You see an old stone altar."
+ *   5 1 0 1 99 "" -> 4 1 0 1
+ *   trailer 134 005e7c962c2c0000...
+ *
+ * `labels` can annotate lines with comments (e.g. verb names), which parsing ignores.
+ */
+export function messagesToText(number, file, labels) {
+    const lines = [`messages ${number} version ${file.version}`, "; noun verb cond seq talker \"text\" [-> noun verb cond seq]"];
+    for (const r of file.records) {
+        const ref = r.ref.noun || r.ref.verb || r.ref.cond || r.ref.seq ? ` -> ${r.ref.noun} ${r.ref.verb} ${r.ref.cond} ${r.ref.seq}` : "";
+        const note = labels?.(r);
+        lines.push(`${r.noun} ${r.verb} ${r.cond} ${r.seq} ${r.talker} ${quoteText(r.text)}${ref}${note ? ` ; ${note}` : ""}`);
+    }
+    if (file.trailer?.length || file.trailerCount) {
+        lines.push(`trailer ${file.trailerCount ?? 0} ${[...(file.trailer ?? [])].map((b) => b.toString(16).padStart(2, "0")).join("")}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function messagesFromText(text) {
+    let number;
+    const file = { version: 4321, records: [] };
+    text.split("\n").forEach((raw, i) => {
+        const line = i + 1;
+        const fail = (why) => {
+            throw new Error(`line ${line}: ${why}`);
+        };
+        const src = raw.trim();
+        if (!src || src.startsWith(";"))
+            return;
+        let m = /^messages\s+(\d+)\s+version\s+(\d+)$/.exec(src);
+        if (m) {
+            number = Number(m[1]);
+            file.version = Number(m[2]);
+            return;
+        }
+        m = /^trailer\s+(\d+)\s*([0-9a-f]*)$/i.exec(src);
+        if (m) {
+            file.trailerCount = Number(m[1]);
+            file.trailer = Uint8Array.from(m[2].match(/../g) ?? [], (h) => parseInt(h, 16));
+            return;
+        }
+        m = /^(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+"((?:[^"\\]|\\.)*)"\s*(?:->\s*(\d+)\s+(\d+)\s+(\d+)\s+(\d+))?\s*(?:;.*)?$/.exec(src);
+        if (!m)
+            fail("expected: noun verb cond seq talker \"text\" [-> noun verb cond seq]");
+        const [n, v, c, s, t, body, rn = "0", rv = "0", rc = "0", rs = "0"] = m.slice(1);
+        const byte = (x, what) => {
+            const value = Number(x);
+            if (value > 255)
+                fail(`${what} ${value} doesn't fit in a byte`);
+            return value;
+        };
+        file.records.push({
+            noun: byte(n, "noun"), verb: byte(v, "verb"), cond: byte(c, "cond"), seq: byte(s, "seq"), talker: byte(t, "talker"),
+            text: unquoteText(body),
+            ref: { noun: byte(rn, "ref noun"), verb: byte(rv, "ref verb"), cond: byte(rc, "ref cond"), seq: byte(rs, "ref seq") },
+        });
+    });
+    if (number === undefined)
+        throw new Error("missing `messages N version V`");
+    return { number, file };
+}
+function quoteText(text) {
+    let s = '"';
+    for (const ch of text) {
+        const c = ch.charCodeAt(0);
+        if (ch === '"')
+            s += '\\"';
+        else if (ch === "\\")
+            s += "\\\\";
+        else if (ch === "\n")
+            s += "\\n";
+        else if (ch === "\r")
+            s += "\\r";
+        else if (c >= 0x20 && c < 0x7f)
+            s += ch;
+        else
+            s += `\\x${c.toString(16).padStart(2, "0")}`;
+    }
+    return `${s}"`;
+}
+function unquoteText(body) {
+    return body.replace(/\\(x[0-9a-fA-F]{2}|.)/g, (_, e) => e === "n" ? "\n" : e === "r" ? "\r" : e.startsWith("x") && e.length === 3 ? String.fromCharCode(parseInt(e.slice(1), 16)) : e);
+}
+/** Noun 0 means "the room itself", so a reference is any non-zero noun, verb or condition. */
+export const hasRef = (r) => r.ref.noun !== 0 || r.ref.verb !== 0 || r.ref.cond !== 0;
+const same = (a, b) => a.noun === b.noun && a.verb === b.verb && a.cond === b.cond && a.seq === b.seq;
+/** Finds a message, following references (bounded, in case of cycles). */
+export function findMessage(file, tuple) {
+    let t = tuple;
+    for (let hops = 0; hops < 8; hops++) {
+        const rec = file.records.find((r) => same(r, t));
+        if (!rec || !hasRef(rec))
+            return rec;
+        t = rec.ref;
+    }
+    return undefined;
+}

package/packages/sci/src/text/message.ts

@@ -0,0 +1,205 @@
+/**
+ * A message is addressed by (noun, verb, condition, sequence), all scoped to a room/module
+ * number (the resource number):
+ *   noun      the thing involved (an object, a character, the room itself)
+ *   verb      what the player did to it (look, do, talk, use an inventory item...)
+ *   condition a game-state variant (e.g. day vs night, class, puzzle solved)
+ *   sequence  1, 2, 3... for multi-line exchanges
+ */
+export interface MessageTuple {
+  noun: number;
+  verb: number;
+  cond: number;
+  seq: number;
+}
+
+export interface MessageRecord extends MessageTuple {
+  /** Who says it. Talker ids are defined by the game scripts (e.g. 99 narrator, 97 hero). */
+  talker: number;
+  text: string;
+  /** Another message to use instead of this one. See `hasRef`. */
+  ref: MessageTuple;
+}
+
+export interface MessageFile {
+  version: number;
+  records: MessageRecord[];
+  /**
+   * Bytes after the strings, kept only so files round-trip: the engine never reads them.
+   * `trailerCount` is the header's entry count; the entries look like editor bookkeeping
+   * (many start with a 4-byte timestamp) and aren't fixed-size.
+   */
+  trailer?: Uint8Array;
+  trailerCount?: number;
+}
+
+/**
+ * SCI1.1/SCI32 message resource (versions 4000–5000 share this layout):
+ *
+ *   +0 u32 version
+ *   +4 u16 end of the strings, counted from +6   +6 u16 trailer entry count
+ *   +8 u16 record count
+ *   +10 records, 11 bytes each:
+ *       noun, verb, cond, seq, talker, u16 string offset, refNoun, refVerb, refCond, refSeq
+ *   NUL-terminated Latin-1 strings, one per record, in record order
+ *   trailer (unused by the engine; editor bookkeeping)
+ *
+ * Measured on all 152 message files of an SCI2 game (versions 4210, 4321, 4341, 5000): no gaps, no
+ * shared strings, so `writeMessages` reproduces them byte for byte.
+ */
+export function parseMessages(data: Uint8Array): MessageFile {
+  const v = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const version = v.getUint32(0, true);
+  if (version < 4000) throw new Error(`Message version ${version} not supported`);
+
+  const decoder = new TextDecoder("latin1");
+  const count = v.getUint16(8, true);
+  const records: MessageRecord[] = [];
+
+  let stringsEnd = 10 + count * 11;
+  for (let i = 0; i < count; i++) {
+    const r = 10 + i * 11;
+    const start = v.getUint16(r + 5, true);
+    let end = start;
+    while (end < data.length && data[end] !== 0) end++;
+    stringsEnd = Math.max(stringsEnd, end + 1);
+    records.push({
+      noun: data[r]!,
+      verb: data[r + 1]!,
+      cond: data[r + 2]!,
+      seq: data[r + 3]!,
+      talker: data[r + 4]!,
+      text: decoder.decode(data.subarray(start, end)),
+      ref: { noun: data[r + 7]!, verb: data[r + 8]!, cond: data[r + 9]!, seq: data[r + 10]! },
+    });
+  }
+  return { version, records, trailer: data.slice(stringsEnd), trailerCount: v.getUint16(6, true) };
+}
+
+const encoder = (text: string) => Uint8Array.from(text, (c) => c.charCodeAt(0) & 0xff);
+
+/** The binary resource for a message file (the inverse of `parseMessages`). */
+export function writeMessages(file: MessageFile): Uint8Array {
+  const strings = file.records.map((r) => encoder(r.text));
+  const recordsEnd = 10 + file.records.length * 11;
+  const stringsEnd = recordsEnd + strings.reduce((n, s) => n + s.length + 1, 0);
+  const trailer = file.trailer ?? new Uint8Array(0);
+  const out = new Uint8Array(stringsEnd + trailer.length);
+  const v = new DataView(out.buffer);
+  v.setUint32(0, file.version, true);
+  v.setUint16(4, stringsEnd - 6, true);
+  v.setUint16(6, file.trailerCount ?? 0, true);
+  v.setUint16(8, file.records.length, true);
+  let at = recordsEnd;
+  file.records.forEach((r, i) => {
+    const o = 10 + i * 11;
+    out.set([r.noun, r.verb, r.cond, r.seq, r.talker], o);
+    v.setUint16(o + 5, at, true);
+    out.set([r.ref.noun, r.ref.verb, r.ref.cond, r.ref.seq], o + 7);
+    out.set(strings[i]!, at);
+    at += strings[i]!.length + 1;
+  });
+  if (stringsEnd > 0xffff) throw new Error("Message file too large (string offsets are 16-bit)");
+  out.set(trailer, stringsEnd);
+  return out;
+}
+
+/**
+ * Message files as text, one record per line, for editing and mods:
+ *
+ *   messages 770 version 4321
+ *   ; noun verb cond seq talker "text"  [-> noun verb cond seq]
+ *   4 1 0 1 99 "You see an old stone altar."
+ *   5 1 0 1 99 "" -> 4 1 0 1
+ *   trailer 134 005e7c962c2c0000...
+ *
+ * `labels` can annotate lines with comments (e.g. verb names), which parsing ignores.
+ */
+export function messagesToText(number: number, file: MessageFile, labels?: (r: MessageRecord) => string | undefined): string {
+  const lines = [`messages ${number} version ${file.version}`, "; noun verb cond seq talker \"text\" [-> noun verb cond seq]"];
+  for (const r of file.records) {
+    const ref = r.ref.noun || r.ref.verb || r.ref.cond || r.ref.seq ? ` -> ${r.ref.noun} ${r.ref.verb} ${r.ref.cond} ${r.ref.seq}` : "";
+    const note = labels?.(r);
+    lines.push(`${r.noun} ${r.verb} ${r.cond} ${r.seq} ${r.talker} ${quoteText(r.text)}${ref}${note ? ` ; ${note}` : ""}`);
+  }
+  if (file.trailer?.length || file.trailerCount) {
+    lines.push(`trailer ${file.trailerCount ?? 0} ${[...(file.trailer ?? [])].map((b) => b.toString(16).padStart(2, "0")).join("")}`);
+  }
+  return `${lines.join("\n")}\n`;
+}
+
+export function messagesFromText(text: string): { number: number; file: MessageFile } {
+  let number: number | undefined;
+  const file: MessageFile = { version: 4321, records: [] };
+  text.split("\n").forEach((raw, i) => {
+    const line = i + 1;
+    const fail = (why: string): never => {
+      throw new Error(`line ${line}: ${why}`);
+    };
+    const src = raw.trim();
+    if (!src || src.startsWith(";")) return;
+    let m = /^messages\s+(\d+)\s+version\s+(\d+)$/.exec(src);
+    if (m) {
+      number = Number(m[1]);
+      file.version = Number(m[2]);
+      return;
+    }
+    m = /^trailer\s+(\d+)\s*([0-9a-f]*)$/i.exec(src);
+    if (m) {
+      file.trailerCount = Number(m[1]);
+      file.trailer = Uint8Array.from(m[2]!.match(/../g) ?? [], (h) => parseInt(h, 16));
+      return;
+    }
+    m = /^(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+"((?:[^"\\]|\\.)*)"\s*(?:->\s*(\d+)\s+(\d+)\s+(\d+)\s+(\d+))?\s*(?:;.*)?$/.exec(src);
+    if (!m) fail("expected: noun verb cond seq talker \"text\" [-> noun verb cond seq]");
+    const [n, v, c, s, t, body, rn = "0", rv = "0", rc = "0", rs = "0"] = m!.slice(1);
+    const byte = (x: string, what: string) => {
+      const value = Number(x);
+      if (value > 255) fail(`${what} ${value} doesn't fit in a byte`);
+      return value;
+    };
+    file.records.push({
+      noun: byte(n!, "noun"), verb: byte(v!, "verb"), cond: byte(c!, "cond"), seq: byte(s!, "seq"), talker: byte(t!, "talker"),
+      text: unquoteText(body!),
+      ref: { noun: byte(rn, "ref noun"), verb: byte(rv, "ref verb"), cond: byte(rc, "ref cond"), seq: byte(rs, "ref seq") },
+    });
+  });
+  if (number === undefined) throw new Error("missing `messages N version V`");
+  return { number, file };
+}
+
+function quoteText(text: string): string {
+  let s = '"';
+  for (const ch of text) {
+    const c = ch.charCodeAt(0);
+    if (ch === '"') s += '\\"';
+    else if (ch === "\\") s += "\\\\";
+    else if (ch === "\n") s += "\\n";
+    else if (ch === "\r") s += "\\r";
+    else if (c >= 0x20 && c < 0x7f) s += ch;
+    else s += `\\x${c.toString(16).padStart(2, "0")}`;
+  }
+  return `${s}"`;
+}
+
+function unquoteText(body: string): string {
+  return body.replace(/\\(x[0-9a-fA-F]{2}|.)/g, (_, e: string) =>
+    e === "n" ? "\n" : e === "r" ? "\r" : e.startsWith("x") && e.length === 3 ? String.fromCharCode(parseInt(e.slice(1), 16)) : e);
+}
+
+/** Noun 0 means "the room itself", so a reference is any non-zero noun, verb or condition. */
+export const hasRef = (r: MessageRecord): boolean => r.ref.noun !== 0 || r.ref.verb !== 0 || r.ref.cond !== 0;
+
+const same = (a: MessageTuple, b: MessageTuple) =>
+  a.noun === b.noun && a.verb === b.verb && a.cond === b.cond && a.seq === b.seq;
+
+/** Finds a message, following references (bounded, in case of cycles). */
+export function findMessage(file: MessageFile, tuple: MessageTuple): MessageRecord | undefined {
+  let t = tuple;
+  for (let hops = 0; hops < 8; hops++) {
+    const rec = file.records.find((r) => same(r, t));
+    if (!rec || !hasRef(rec)) return rec;
+    t = rec.ref;
+  }
+  return undefined;
+}

package/packages/sci/src/vm/kernels/arrays.d.ts

@@ -0,0 +1,19 @@
+import type { SciArray } from "../memory.ts";
+import type { KernelFn, Vm } from "../vm.ts";
+import { type Value } from "../value.ts";
+/** Resolves an array argument: an array ref, or a String/Array object holding one in `data`. */
+declare function resolve(vm: Vm, v: Value): SciArray | undefined;
+declare const str: (vm: Vm, v: Value) => string;
+declare function newString(vm: Vm, s: string): Value;
+declare function writeString(vm: Vm, ref: Value, s: string): Value;
+/** printf-style formatting, as SCI's StringFormat understands it. */
+export declare function sciFormat(vm: Vm, format: string, args: Value[]): string;
+/** SCI32 dynamic arrays and strings. */
+export declare const arrayKernels: Record<string, KernelFn>;
+export declare const stringHelpers: {
+    str: typeof str;
+    newString: typeof newString;
+    writeString: typeof writeString;
+    resolve: typeof resolve;
+};
+export {};

package/packages/sci/src/vm/kernels/arrays.js

@@ -0,0 +1,182 @@
+import { NULL, fromInt, isNumber, segmentOf, toSigned } from "../value.js";
+const arrayTypes = ["int16", "id", "byte", "string"];
+/** Resolves an array argument: an array ref, or a String/Array object holding one in `data`. */
+function resolve(vm, v) {
+    const direct = vm.memory.array(v);
+    if (direct)
+        return direct;
+    const obj = vm.memory.object(v);
+    if (obj) {
+        const data = vm.getProp(obj, "data");
+        if (data !== undefined)
+            return vm.memory.array(data);
+    }
+    return undefined;
+}
+const store = (a, value) => (a.type === "byte" || a.type === "string" ? value & 0xff : value);
+function setElements(vm, [ref = 0, index = 0, ...values]) {
+    const a = resolve(vm, ref);
+    if (!a)
+        return ref;
+    const start = toSigned(index);
+    values.forEach((v, i) => {
+        a.data[start + i] = store(a, v);
+    });
+    for (let i = 0; i < a.data.length; i++)
+        a.data[i] ??= 0;
+    return ref;
+}
+/** Byte values of a string argument: literal in a script heap or an array. */
+function chars(vm, v) {
+    const a = resolve(vm, v);
+    if (a) {
+        const out = [];
+        for (const c of a.data) {
+            if ((c & 0xff) === 0)
+                break;
+            out.push(c & 0xff);
+        }
+        return out;
+    }
+    if (!v)
+        return [];
+    return [...vm.memory.string(v)].map((c) => c.charCodeAt(0));
+}
+const str = (vm, v) => String.fromCharCode(...chars(vm, v));
+function newString(vm, s) {
+    const ref = vm.memory.newArray("string", s.length + 1);
+    const a = vm.memory.array(ref);
+    for (let i = 0; i < s.length; i++)
+        a.data[i] = s.charCodeAt(i) & 0xff;
+    return ref;
+}
+function writeString(vm, ref, s) {
+    const a = resolve(vm, ref);
+    if (!a)
+        return ref;
+    a.data.length = 0;
+    for (let i = 0; i < s.length; i++)
+        a.data.push(s.charCodeAt(i) & 0xff);
+    a.data.push(0);
+    return ref;
+}
+function copy(vm, [dst = 0, dstIndex = 0, src = 0, srcIndex = 0, count = 0xffff]) {
+    const d = resolve(vm, dst);
+    if (!d)
+        return dst;
+    const s = resolve(vm, src);
+    const from = s ? s.data : chars(vm, src).concat(0);
+    const start = toSigned(srcIndex);
+    let n = toSigned(count);
+    if (n < 0)
+        n = from.length - start;
+    for (let i = 0; i < n && start + i < from.length; i++)
+        d.data[toSigned(dstIndex) + i] = store(d, from[start + i]);
+    for (let i = 0; i < d.data.length; i++)
+        d.data[i] ??= 0;
+    return dst;
+}
+/** printf-style formatting, as SCI's StringFormat understands it. */
+export function sciFormat(vm, format, args) {
+    let argi = 0;
+    return format.replace(/%(-?)(0?)(\d*)([dsuxXc%])/g, (_m, left, zero, width, conv) => {
+        if (conv === "%")
+            return "%";
+        const arg = args[argi++] ?? 0;
+        let out;
+        switch (conv) {
+            case "d":
+                out = String(toSigned(arg));
+                break;
+            case "u":
+                out = String(arg & 0xffff);
+                break;
+            case "x":
+                out = (arg & 0xffff).toString(16);
+                break;
+            case "X":
+                out = (arg & 0xffff).toString(16).toUpperCase();
+                break;
+            case "c":
+                out = String.fromCharCode(arg & 0xff);
+                break;
+            default: out = isNumber(arg) && arg !== 0 ? String(toSigned(arg)) : str(vm, arg);
+        }
+        const w = Number(width || 0);
+        return left ? out.padEnd(w) : out.padStart(w, zero ? "0" : " ");
+    });
+}
+const arraySubops = {
+    0: (vm, [size = 0, type = 0]) => vm.memory.newArray(arrayTypes[type] ?? "int16", size),
+    1: (vm, [ref = 0]) => resolve(vm, ref)?.data.length ?? 0,
+    2: (vm, [ref = 0, index = 0]) => resolve(vm, ref)?.data[toSigned(index)] ?? 0,
+    3: setElements,
+    4: (vm, [ref = 0]) => {
+        if (vm.memory.array(ref))
+            vm.memory.free(segmentOf(ref));
+        return 0;
+    },
+    5: (vm, [ref = 0, index = 0, count = 0, value = 0]) => {
+        const a = resolve(vm, ref);
+        if (a)
+            for (let i = 0; i < count; i++)
+                a.data[toSigned(index) + i] = store(a, value);
+        if (a)
+            for (let i = 0; i < a.data.length; i++)
+                a.data[i] ??= 0;
+        return ref;
+    },
+    6: copy,
+    8: (vm, [ref = 0]) => {
+        const a = resolve(vm, ref);
+        if (!a)
+            return NULL;
+        const dup = vm.memory.newArray(a.type, 0);
+        vm.memory.array(dup).data = a.data.slice();
+        return dup;
+    },
+    9: (vm, [ref = 0]) => {
+        const obj = vm.memory.object(ref);
+        return obj ? (vm.getProp(obj, "data") ?? ref) : ref;
+    },
+};
+const stringSubops = {
+    ...arraySubops,
+    0: (vm, [size = 0]) => vm.memory.newArray("string", size),
+    // Duplicate: also takes a literal string from a script's heap (e.g. `Prints "text"`).
+    8: (vm, args) => (resolve(vm, args[0] ?? 0) ? arraySubops[8](vm, args) : newString(vm, str(vm, args[0] ?? 0))),
+    7: (vm, [a = 0, b = 0, n]) => {
+        let x = str(vm, a), y = str(vm, b);
+        if (n !== undefined)
+            (x = x.slice(0, n), (y = y.slice(0, n)));
+        return fromInt(x < y ? -1 : x > y ? 1 : 0);
+    },
+    10: (vm, [s = 0]) => chars(vm, s).length,
+    11: (vm, [format = 0, ...args]) => newString(vm, sciFormat(vm, str(vm, format), args)),
+    12: (vm, [dst = 0, format = 0, ...args]) => writeString(vm, dst, sciFormat(vm, str(vm, format), args)),
+    13: (vm, [s = 0]) => fromInt(parseInt(str(vm, s), 10) || 0),
+    14: (vm, [s = 0, flags = 0]) => {
+        let t = str(vm, s);
+        if (flags & 1)
+            t = t.trimStart();
+        if (flags & 2)
+            t = t.trimEnd();
+        if (flags & 4)
+            t = t.replace(/ /g, "");
+        return writeString(vm, s, t);
+    },
+    15: (vm, [s = 0]) => writeString(vm, s, str(vm, s).toUpperCase()),
+    16: (vm, [s = 0]) => writeString(vm, s, str(vm, s).toLowerCase()),
+};
+const dispatch = (name, table) => (vm, [op = 0, ...args]) => {
+    const fn = table[op];
+    if (!fn)
+        throw new Error(`${name} subop ${op} not implemented`);
+    return fn(vm, args);
+};
+/** SCI32 dynamic arrays and strings. */
+export const arrayKernels = {
+    Array: dispatch("Array", arraySubops),
+    String: dispatch("String", stringSubops),
+};
+export const stringHelpers = { str, newString, writeString, resolve };