@scriptc/compiler 0.4.6 → 0.4.7

package/dist/frontend/lowering/lower-calls.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/frontend/lowering/lower-calls.test.js

@@ -0,0 +1,78 @@
+import { expect, test } from "vitest";
+import { DYN } from "../../ir/ir.js";
+import { isPlainDescriptorMap, isPlainObjectLiteral } from "./lower-calls.js";
+const loc = { file: "descriptors.ts", start: 0, end: 1 };
+function dynObjLit() {
+    return { kind: "dynObjLit", fields: [], type: DYN, loc };
+}
+function recordLit() {
+    return { kind: "recordLit", fields: [], type: { kind: "record", shapeId: "r1" }, loc };
+}
+function recordClone() {
+    return {
+        kind: "recordClone",
+        source: recordLit(),
+        overrides: [],
+        type: { kind: "record", shapeId: "r1" },
+        loc,
+    };
+}
+function dynFrom(value) {
+    return { kind: "dynFrom", value, type: DYN, loc };
+}
+test("a plain object keeps the default descriptor reader", () => {
+    expect(isPlainObjectLiteral(dynObjLit())).toBe(true);
+    // A typed object literal boxes into dyn through dynFrom, and so does any
+    // expression already of a record type (a variable, a clone).
+    expect(isPlainObjectLiteral(dynFrom(recordLit()))).toBe(true);
+    expect(isPlainObjectLiteral(dynFrom(recordClone()))).toBe(true);
+    const recordVariable = {
+        kind: "varRef",
+        localId: "p1",
+        type: { kind: "record", shapeId: "r1" },
+        loc,
+    };
+    expect(isPlainObjectLiteral(dynFrom(recordVariable))).toBe(true);
+});
+test("any other descriptor may be an object of any kind and takes the any-object entry points", () => {
+    const variable = { kind: "varRef", localId: "p0", type: DYN, loc };
+    const array = { kind: "dynArrLit", elems: [], type: DYN, loc };
+    const call = {
+        kind: "libCall",
+        fn: "dyn.objCreate",
+        args: [dynObjLit()],
+        type: DYN,
+        loc,
+    };
+    for (const expr of [variable, dynFrom(variable), array, call])
+        expect(isPlainObjectLiteral(expr)).toBe(false);
+});
+test("a descriptor map is plain only when every descriptor in it is plain", () => {
+    const key = { kind: "strLit", value: "a", type: { kind: "string" }, loc };
+    const variable = { kind: "varRef", localId: "p0", type: DYN, loc };
+    const map = (value) => ({
+        kind: "dynObjLit",
+        fields: [{ key, value }],
+        type: DYN,
+        loc,
+    });
+    const shapes = new Map([
+        ["r1", { id: "r1", fields: [] }],
+        ["plain", { id: "plain", fields: [{ name: "a", type: { kind: "record", shapeId: "r1" } }] }],
+        ["dyn", { id: "dyn", fields: [{ name: "a", type: DYN }] }],
+    ]);
+    const record = (shapeId) => ({
+        kind: "varRef",
+        localId: "p1",
+        type: { kind: "record", shapeId },
+        loc,
+    });
+    const getRecord = (id) => shapes.get(id);
+    expect(isPlainDescriptorMap(map(dynObjLit()), getRecord)).toBe(true);
+    expect(isPlainDescriptorMap(dynFrom(record("plain")), getRecord)).toBe(true);
+    // `{ a: view }` with `view` a DataView, an array or any other dyn value.
+    expect(isPlainDescriptorMap(map(variable), getRecord)).toBe(false);
+    expect(isPlainDescriptorMap(dynFrom(record("dyn")), getRecord)).toBe(false);
+    expect(isPlainDescriptorMap(variable, getRecord)).toBe(false);
+});
+//# sourceMappingURL=lower-calls.test.js.map

package/dist/frontend/lowering/lower-calls.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lower-calls.test.js","sourceRoot":"","sources":["../../../src/frontend/lowering/lower-calls.test.ts"],"names":[],"mappings":"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"}

package/dist/frontend/lowering/lower-classes.d.ts

@@ -13,7 +13,15 @@ export declare function returnsOnlyThis(member: ts.MethodDeclaration): boolean;
  * claim setters). Used only to narrow a call's result back to the
  * receiver's class. */
 export declare function returnsOnlyThisValue(member: ts.MethodDeclaration): boolean;
-export declare function functionLocalClass(decl: ts.ClassLikeDeclaration): boolean;
+/** True when evaluating this class definition creates a class VALUE more
+ * than once, so each evaluation must mint its own constructor object,
+ * prototype and statics. A function body runs per call, a loop body per
+ * iteration, and an instance field initializer (or constructor parameter
+ * default) per construction. A class expression nested in a STATIC member
+ * initializer, a computed key or the heritage follows its enclosing
+ * class's own evaluation, so the walk continues through those.
+ * Top-level definitions evaluated once keep the immortal template. */
+export declare function perEvaluationClass(decl: ts.ClassLikeDeclaration): boolean;
 export declare function storedClassValueType(lowerer: Lowerer, expression: ts.Expression, visiting?: Set<import("../ts7/ast-node.js").AstNode>): IrType | null;
 export interface ClassMethodSignature {
     params: ParamShape[];
@@ -594,10 +602,13 @@ export declare function staticReceiverClass(lowerer: Lowerer, receiver: ts.Expre
  * property access `site`, or a destructuring element over `C` whose
  * initializer is `site`. Null when the class has no such member. */
 export declare function lowerClassStaticRead(lowerer: Lowerer, info: ClassInfo, name: string, receiver: ts.Expression, site: ts.Expression): IrExpr | null;
-/** Collect a class expression once per enclosing specialization. Function-local
- * evaluations allocate fresh constructor objects; top-level expressions use
- * immortal templates. Static initialization remains limited to whole top-level
- * initializers, where pendingClassExprInits preserves its evaluation point. */
+/** Collect a class expression once per enclosing specialization. A class
+ * definition the program can EVALUATE more than once (perEvaluationClass:
+ * a function body, a loop body, an instance initializer) allocates fresh
+ * constructor objects, so identity, statics and prototype belong to that
+ * evaluation; definitions evaluated once use immortal templates. Static
+ * initialization remains limited to whole top-level initializers, where
+ * pendingClassExprInits preserves its evaluation point. */
 export declare function lowerClassExpressionInfo(lowerer: Lowerer, expr: ts.ClassLikeDeclaration): ClassInfo;
 /** `class {…}` in expression position: a class definition bound to no
  * statement — once the static side is a value, the expression IS the

package/dist/frontend/lowering/lower-classes.js

@@ -1,3 +1,4 @@
+import { lowerWrapperNew } from "./primitive-wrappers.js";
 import { lowerAsyncLocalStorageOptions } from "./builtins/async-context.js";
 import { shapeOverlayAnnotated } from "../shape-inference/index.js";
 import { DATE_TIME_FIELD, dateRootOf, dateSuperCall, isDatePrototypeMethod, lowerDateSuperMethodCall, } from "./builtins/date-classes.js";
@@ -131,13 +132,41 @@ export function returnsOnlyThisValue(member) {
     ts.forEachChild(body, visit);
     return valid;
 }
-export function functionLocalClass(decl) {
-    for (let parent = decl.parent; parent && !ts.isSourceFile(parent); parent = parent.parent) {
-        if (ts.isFunctionLike(parent))
+/** True when evaluating this class definition creates a class VALUE more
+ * than once, so each evaluation must mint its own constructor object,
+ * prototype and statics. A function body runs per call, a loop body per
+ * iteration, and an instance field initializer (or constructor parameter
+ * default) per construction. A class expression nested in a STATIC member
+ * initializer, a computed key or the heritage follows its enclosing
+ * class's own evaluation, so the walk continues through those.
+ * Top-level definitions evaluated once keep the immortal template. */
+export function perEvaluationClass(decl) {
+    let child = decl;
+    for (let parent = decl.parent; parent && !ts.isSourceFile(parent); child = parent, parent = parent.parent) {
+        if (ts.isFunctionLike(parent) || ts.isClassStaticBlockDeclaration(parent))
+            return true;
+        if (ts.isForStatement(parent) ||
+            ts.isForInStatement(parent) ||
+            ts.isForOfStatement(parent) ||
+            ts.isWhileStatement(parent) ||
+            ts.isDoStatement(parent))
+            return true;
+        if ((ts.isClassDeclaration(parent) || ts.isClassExpression(parent)) && perInstanceMember(child))
             return true;
     }
     return false;
 }
+/** True when `node` — the direct child of the enclosing class on the path
+ * to a nested class definition — is evaluated once per INSTANCE: an
+ * instance field with an initializer, or a constructor whose parameters
+ * have defaults (parameter properties included). */
+function perInstanceMember(node) {
+    if (ts.isConstructorDeclaration(node))
+        return node.parameters.nodes.some((param) => param.initializer !== undefined);
+    if (!ts.isPropertyDeclaration(node) || node.initializer === undefined)
+        return false;
+    return !ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword);
+}
 export function storedClassValueType(lowerer, expression, visiting = new Set()) {
     if (visiting.has(expression))
         return null;
@@ -145,7 +174,7 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
     if (ts.isParenthesizedExpression(expression))
         return storedClassValueType(lowerer, expression.expression, visiting);
     if (ts.isClassExpression(expression) &&
-        !functionLocalClass(expression) &&
+        !perEvaluationClass(expression) &&
         !lowerer.collectingExprClasses.has(expression)) {
         const info = lowerer.lowerClassExpressionInfo(expression);
         return { kind: "classval", className: info.def.name };
@@ -189,7 +218,7 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
             const declaration = constructor && ts.isConstructorDeclaration(constructor) ? constructor.parent : undefined;
             if (declaration &&
                 ts.isClassExpression(declaration) &&
-                !functionLocalClass(declaration) &&
+                !perEvaluationClass(declaration) &&
                 !lowerer.collectingExprClasses.has(declaration)) {
                 const info = lowerer.lowerClassExpressionInfo(declaration);
                 return { kind: "classval", className: info.def.name };
@@ -1461,7 +1490,13 @@ mixin) {
                 const emitterBase = lowerer.builtinEmitterInfoOf(resolved);
                 const streamBaseNs = builtinStreamInfoOf(lowerer, resolved);
                 if (emitterBase || streamBaseNs) {
-                    if (t.typeArguments?.nodes)
+                    // An EventEmitter's type argument is the listener MAP, a pure
+                    // typing aid: the emitter base is one runtime class whatever the
+                    // map says, and the map's keys never reach the layout (Node's
+                    // own generic erases at runtime), so `extends
+                    // EventEmitter<MyEvents>` adopts the same base. A stream base's
+                    // argument IS the element layout, which still has to be concrete.
+                    if (!emitterBase && t.typeArguments?.nodes)
                         lowerer.unsupported("SC1090", t, "extending generic classes");
                     base = (emitterBase ?? streamBaseNs);
                     continue;
@@ -1652,7 +1687,12 @@ mixin) {
                 base = instBase;
                 continue;
             }
-            if (t.typeArguments?.nodes)
+            // An EventEmitter base's type argument is the listener MAP — a pure
+            // typing aid (the runtime base is one emitter class whatever the map
+            // says, and Node erases it too), so `extends EventEmitter<Events>`
+            // adopts the same base. Every other generic base still refuses:
+            // its argument can carry a layout.
+            if (t.typeArguments?.nodes && lowerer.builtinEmitterInfoOf(symbol) === null)
                 lowerer.unsupported("SC1090", t, "extending generic classes");
             if (named?.extendsArray)
                 lowerer.unsupported("SC1090", t, `extending '${t.expression.text}', a class that extends Array (one level of Array subclass compiles)`);
@@ -1674,7 +1714,7 @@ mixin) {
                 throw new PoisonError();
             }
         }
-        if (base?.localClass && !functionLocalClass(decl) && !computedBase && !factoryBaseExpression) {
+        if (base?.localClass && !perEvaluationClass(decl) && !computedBase && !factoryBaseExpression) {
             const heritage = decl.heritageClauses?.nodes.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types?.nodes[0];
             if (heritage)
                 factoryBaseExpression = heritage.expression;
@@ -1741,7 +1781,13 @@ mixin) {
                 decl.members.nodes.some((member) => ts.isAccessor(member) &&
                     !ts.isPrivateIdentifier(member.name) &&
                     member.modifiers?.nodes.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) &&
-            !decl.members.nodes.some((member) => member.name &&
+            // A private static ACCESSOR has no native storage yet, and a private
+            // static method that reads `arguments` would lose the arguments past
+            // its parameters when called through its value (`this.#m` returned by
+            // a getter): keep such a class on the static path, whose public
+            // static accessors refuse.
+            !decl.members.nodes.some((member) => (ts.isAccessor(member) ||
+                (ts.isMethodDeclaration(member) && bodyReadsArguments(member))) &&
                 ts.isPrivateIdentifier(member.name) &&
                 ts
                     .getModifiers(member)
@@ -1796,17 +1842,31 @@ mixin) {
             });
         };
         for (const member of decl.members.nodes) {
-            if ((functionLocalClass(decl) || checkedStatics) &&
+            if ((perEvaluationClass(decl) || checkedStatics) &&
                 (isJsSourceFile(ts.getSourceFileOfNode(decl)) ||
-                    (functionLocalClass(decl) && ts.isMethodDeclaration(member))) &&
+                    (perEvaluationClass(decl) && ts.isMethodDeclaration(member))) &&
                 (ts.isClassStaticBlockDeclaration(member) ||
                     ts
                         .getModifiers(member)
                         ?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) {
-                runtimeStatics.push(member);
-                continue;
+                // A private static of a declaration-level class keeps its native
+                // storage (the %C.static:#m function, the %g.s.C.#x global): the
+                // constructor object never carries a property for it, and every
+                // access brand-checks its receiver (private-statics.ts). A field
+                // also stays in runtimeStatics, so its initializer runs in source
+                // order with the constructor's other initializers.
+                const privateStatic = checkedStatics &&
+                    !perEvaluationClass(decl) &&
+                    member.name !== undefined &&
+                    ts.isPrivateIdentifier(member.name);
+                if (!privateStatic) {
+                    runtimeStatics.push(member);
+                    continue;
+                }
+                if (ts.isPropertyDeclaration(member))
+                    runtimeStatics.push(member);
             }
-            if (functionLocalClass(decl) &&
+            if (perEvaluationClass(decl) &&
                 isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
                 (ts.isMethodDeclaration(member) || ts.isAccessor(member)) &&
                 member.body &&
@@ -1900,7 +1960,7 @@ mixin) {
                     }
                     staticMethods.set(member.name.text, { params: shapes, ret: ft.ret, member });
                     if (implicitMonoFile(ts.getSourceFileOfNode(decl)) &&
-                        !functionLocalClass(decl) &&
+                        !perEvaluationClass(decl) &&
                         inst === undefined &&
                         decl.typeParameters === undefined) {
                         const implicit = implicitAnyParamSymbolsOf(lowerer, member, true);
@@ -2530,7 +2590,7 @@ mixin) {
                 // name (the override stays on the vtable), a shadowed field, or
                 // a generic-class instantiation's member.
                 if (implicitMonoFile(ts.getSourceFileOfNode(decl)) &&
-                    !functionLocalClass(decl) &&
+                    !perEvaluationClass(decl) &&
                     ts.isIdentifier(member.name) &&
                     !lowerer.virtualJsMethods.has(member) &&
                     !lowerer.checkedJsOverrideMethods.has(member) &&
@@ -2741,7 +2801,7 @@ mixin) {
                     // boundary (lowerClassMethodMemberInner).
                     const ownAsync = member.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
                     if (!fencedJsOverride &&
-                        !functionLocalClass(decl) &&
+                        !perEvaluationClass(decl) &&
                         overridden.sig.gen === undefined &&
                         // An async base's slot answers its promise: a Promise type, or
                         // the checked-dynamic value of an untyped async method.
@@ -2830,7 +2890,7 @@ mixin) {
                     !returnAdapters.has(mName) &&
                     (asyncMember || overridden.sig.async === true) &&
                     !isJsSourceFile(ts.getSourceFileOfNode(member)) &&
-                    !functionLocalClass(decl) &&
+                    !perEvaluationClass(decl) &&
                     member.asteriskToken === undefined &&
                     overridden.sig.gen === undefined &&
                     !overridden.sig.abstract &&
@@ -3622,7 +3682,7 @@ mixin) {
             lowerer.subclassLinks++;
         }
         lowerer.classes.set(className, info);
-        if (computedBase && !functionLocalClass(decl)) {
+        if (computedBase && !perEvaluationClass(decl)) {
             info.def.baseValueGlobal = `%g.${className}.computedBase`;
             lowerer.globalsList.push({
                 id: info.def.baseValueGlobal,
@@ -3631,7 +3691,7 @@ mixin) {
                 mutable: false,
             });
         }
-        if (factoryBaseExpression && !functionLocalClass(decl)) {
+        if (factoryBaseExpression && !perEvaluationClass(decl)) {
             info.def.baseValueGlobal = `%g.${className}.computedBase`;
             lowerer.globalsList.push({
                 id: info.def.baseValueGlobal,
@@ -3640,7 +3700,7 @@ mixin) {
                 mutable: false,
             });
         }
-        if (callableBase && !functionLocalClass(decl)) {
+        if (callableBase && !perEvaluationClass(decl)) {
             lowerer.globalsList.push({ id: callableBase.constructorId, name: `${className} base`, type: DYN, mutable: false }, {
                 id: callableBase.prototypeId,
                 name: `${className} base prototype`,
@@ -4109,7 +4169,11 @@ function lowerStaticFieldInitsInner(lowerer, info) {
         });
     }
     const items = [
-        ...info.staticFields.map((f) => ({
+        // A runtime-statics class initializes its private static fields with
+        // its other initializers (initializeRuntimeStatics).
+        ...info.staticFields
+            .filter((f) => !(info.runtimeStatics && f.name.startsWith("#")))
+            .map((f) => ({
             pos: ts.tokenStartOfNode(f.initializer),
             kind: "field",
             f,
@@ -4721,7 +4785,7 @@ export function lowerClassStaticRead(lowerer, info, name, receiver, site) {
         ["now", "parse", "UTC"].includes(name) &&
         !(ts.isCallExpression(site.parent) && site.parent.expression === site))
         lowerer.noLowering(`Date.${name} read through a class that extends Date`, site);
-    if (hasRuntimeStatics(info) && !found?.field)
+    if (hasRuntimeStatics(info) && !found?.field && !name.startsWith("#"))
         return {
             kind: "dynKeyGet",
             value: lowerer.coerceToExpected(classValueRef(lowerer, info, receiver), DYN),
@@ -4889,10 +4953,13 @@ function privateNamesOnlyOnThis(expr) {
     }
     return true;
 }
-/** Collect a class expression once per enclosing specialization. Function-local
- * evaluations allocate fresh constructor objects; top-level expressions use
- * immortal templates. Static initialization remains limited to whole top-level
- * initializers, where pendingClassExprInits preserves its evaluation point. */
+/** Collect a class expression once per enclosing specialization. A class
+ * definition the program can EVALUATE more than once (perEvaluationClass:
+ * a function body, a loop body, an instance initializer) allocates fresh
+ * constructor objects, so identity, statics and prototype belong to that
+ * evaluation; definitions evaluated once use immortal templates. Static
+ * initialization remains limited to whole top-level initializers, where
+ * pendingClassExprInits preserves its evaluation point. */
 export function lowerClassExpressionInfo(lowerer, expr) {
     const cached = lowerer.exprClassInfoByName.get(lowerer.classNamer(expr));
     if (cached)
@@ -4907,14 +4974,12 @@ export function lowerClassExpressionInfo(lowerer, expr) {
     if (lowerer.collectingExprClasses.has(expr)) {
         lowerer.unsupported("SC1090", expr, "class expressions whose extends chain re-enters their own collection (a cyclic base through property assignments)");
     }
-    let local = false;
     for (let p = expr.parent; p !== undefined && !ts.isSourceFile(p); p = p.parent) {
         if (ts.isClassStaticBlockDeclaration(p)) {
             lowerer.unsupported("SC1090", expr, "class expressions inside static blocks");
         }
-        if (ts.isFunctionLike(p))
-            local = true;
     }
+    const local = perEvaluationClass(expr);
     if (local &&
         expr.members.nodes.some((member) => member.name && ts.isPrivateIdentifier(member.name)) &&
         !localPrivateFieldsAgree(expr)) {
@@ -5539,7 +5604,9 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
         if (date)
             return date;
     }
-    if ((hasRuntimeStatics(info) && !findStaticOn(lowerer, info, access.name.text)?.field) ||
+    if ((hasRuntimeStatics(info) &&
+        !access.name.text.startsWith("#") &&
+        !findStaticOn(lowerer, info, access.name.text)?.field) ||
         (info.callableBase &&
             !findStaticOn(lowerer, info, access.name.text) &&
             !findGenericStaticOn(lowerer, info, access.name.text)))
@@ -5925,7 +5992,9 @@ export function lowerClassValueProperty(lowerer, expr) {
     if (info?.def.runtime && member !== "name")
         return null;
     if (info &&
-        ((hasRuntimeStatics(info) && !findStaticOn(lowerer, info, member)?.field) ||
+        ((hasRuntimeStatics(info) &&
+            !member.startsWith("#") &&
+            !findStaticOn(lowerer, info, member)?.field) ||
             (info.callableBase && !findStaticOn(lowerer, info, member))))
         return {
             kind: "dynKeyGet",
@@ -6142,7 +6211,7 @@ function localSubclassesOf(lowerer, base) {
             ts.walkPreorder(sf, (node) => {
                 if ((ts.isClassDeclaration(node) || ts.isClassExpression(node)) &&
                     node.heritageClauses !== undefined &&
-                    functionLocalClass(node)) {
+                    perEvaluationClass(node)) {
                     const extended = extendedClassNode(lowerer, node);
                     if (extended) {
                         const list = index.get(extended);
@@ -8473,6 +8542,20 @@ function lowerProgramClassNew(lowerer, expr, declaredInfo, loc) {
         loc,
     });
 }
+/** The supported map layout a contextual type pins for `new Map()`: the type
+ * itself, or the single map arm of a union — a nullable annotation such as
+ * `Map<K, V> | undefined`, or `ReadonlyMap<K, V> | undefined`, where a Map
+ * value can only inhabit the map arm and the no-argument constructor gives
+ * the checker nothing to infer the type arguments from. */
+function contextualMapLayout(lowerer, ctx) {
+    const mapped = lowerer.mapTypeOf(ctx);
+    if (mapped?.kind === "map")
+        return mapped;
+    if (mapped?.kind !== "union")
+        return null;
+    const arms = (lowerer.unions.get(mapped.unionId)?.arms ?? []).filter((arm) => arm.kind === "map");
+    return arms.length === 1 ? arms[0] : null;
+}
 function assignedThisFieldType(lowerer, expr) {
     const parent = expr.parent;
     if (!ts.isBinaryExpression(parent) ||
@@ -8571,6 +8654,9 @@ export function lowerNew(lowerer, expr) {
             return lowerWithInlineRequireInit(lowerer, req, () => lowerNew(lowerer, expr));
         }
     }
+    const wrapper = lowerWrapperNew(lowerer, expr);
+    if (wrapper)
+        return wrapper;
     const worker = lowerWorkerNew(lowerer, expr);
     if (worker)
         return worker;
@@ -8644,7 +8730,15 @@ export function lowerNew(lowerer, expr) {
         expr.expression.name.text === "Segmenter" &&
         lowerer.isStdlibGlobal(expr.expression.expression, "Intl")) {
         const args = expr.arguments?.nodes ?? [];
-        const undefinedArg = (arg) => (lowerer.typeOf(arg).flags & ts.TypeFlags.Undefined) !== 0;
+        // An argument whose value IS undefined: exactly undefined, or void. A
+        // union that merely includes undefined may hold a locale or an options
+        // object at run time, and the constructor cannot inspect either — such
+        // an argument is refused below rather than silently read as the default
+        // locale or the default options.
+        const undefinedArg = (arg) => {
+            const flags = lowerer.typeOf(arg).flags;
+            return flags === ts.TypeFlags.Undefined || flags === ts.TypeFlags.Void;
+        };
         // A literal language tag: Unicode grapheme clusters have no locale
         // tailoring. Only tags of the form language[-script][-region] are
         // accepted; each is well-formed, so Node constructs the segmenter
@@ -8654,27 +8748,28 @@ export function lowerNew(lowerer, expr) {
         if (args.length > 2 || (args[0] && !undefinedArg(args[0]) && !literalLocale(args[0]))) {
             lowerer.noLowering("Intl.Segmenter locale negotiation", expr, "omit the locale, pass undefined, or pass one language tag as a string literal");
         }
-        // JavaScript dependencies may construct word and sentence segmenters
-        // that they use only on some paths (pi-tui's shared word segmenter):
-        // the construction compiles and their segment() throws SC2020.
-        // TypeScript sources keep the build-time refusal.
+        // Word segmentation lowers through ICU (scr_intl.c). Sentence
+        // segmentation does not: JavaScript dependencies may construct sentence
+        // segmenters they use only on some paths, so the construction compiles
+        // and their segment() throws SC2020; TypeScript sources keep the
+        // build-time refusal.
         const granularities = isJsSourceFile(ts.getSourceFileOfNode(expr))
             ? ["grapheme", "word", "sentence"]
-            : ["grapheme"];
+            : ["grapheme", "word"];
         const options = args[1];
         let granularity = "grapheme";
         if (options && !undefinedArg(options)) {
             // An object literal of `granularity` entries (none: the default; a
             // repeated key: the last one, as in JavaScript).
             if (!ts.isObjectLiteralExpression(options))
-                lowerer.noLowering("Intl.Segmenter options", options, 'the native segmenter supports default options and { granularity: "grapheme" }; word and sentence segmentation remain unsupported');
+                lowerer.noLowering("Intl.Segmenter options", options, 'the native segmenter supports default options, { granularity: "grapheme" } and { granularity: "word" }; sentence segmentation remains unsupported');
             for (const property of options.properties.nodes) {
                 if (!ts.isPropertyAssignment(property) ||
                     !(ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) ||
                     property.name.text !== "granularity" ||
                     !ts.isStringLiteral(property.initializer) ||
                     !granularities.includes(property.initializer.text)) {
-                    lowerer.noLowering("Intl.Segmenter options", options, 'the native segmenter supports default options and { granularity: "grapheme" }; word and sentence segmentation remain unsupported');
+                    lowerer.noLowering("Intl.Segmenter options", options, 'the native segmenter supports default options, { granularity: "grapheme" } and { granularity: "word" }; sentence segmentation remains unsupported');
                 }
                 granularity = property.initializer.text;
             }
@@ -8688,12 +8783,28 @@ export function lowerNew(lowerer, expr) {
                 loc: locOf(arg),
             };
         });
+        // Grapheme segmentation is the engine-free table-driven segmenter
+        // (scr_grapheme.c). NOTE: once ICU is established everywhere, this fast
+        // path is deleted in favor of ICU's character iterator (design I4).
         let result = { kind: "libCall", fn: "intl.segmenterNew", args: [], type: DYN, loc };
-        // A word or sentence segmenter carries its segment() refusal, which
-        // coverage lists as deferred to runtime.
-        if (granularity !== "grapheme") {
+        if (granularity === "word") {
+            // ICU's word iterator at the requested locale; a literal language tag
+            // is the locale, and the empty string means the default locale (what
+            // Node negotiates when the argument is absent or undefined).
+            const tag = args[0] !== undefined && ts.isStringLiteralLike(args[0]) ? args[0].text : "";
+            result = {
+                kind: "libCall",
+                fn: "icu.segmenterWord",
+                args: [strLit(tag, loc)],
+                type: DYN,
+                loc,
+            };
+        }
+        // A sentence segmenter carries its segment() refusal, which coverage
+        // lists as deferred to runtime.
+        if (granularity === "sentence") {
             const surface = `Intl.Segmenter segmentation with granularity '${granularity}'`;
-            lowerer.runtimeFences.push(noLoweringDiag(surface, loc, "only grapheme segmenters segment; word and sentence segmenters construct"));
+            lowerer.runtimeFences.push(noLoweringDiag(surface, loc, "only grapheme and word segmenters segment; sentence segmenters construct"));
             const line = ts.getLineAndCharacterOfPosition(ts.getSourceFileOfNode(expr), loc.start).line;
             const refusal = `${surface} is not supported yet [SC2020 at ${loc.file}:${line + 1}]`;
             result = {
@@ -9234,8 +9345,9 @@ export function lowerNew(lowerer, expr) {
         // starting at 0 (nothing buffered). A literal Buffer encoding folds
         // its alias at compile time; any other encoding argument is
         // normalized at run time (Node's normalizeEncoding, which throws
-        // ERR_UNKNOWN_ENCODING for an unknown name). Omitted means utf8,
-        // Node's default.
+        // ERR_UNKNOWN_ENCODING for an unknown name). An encoding that may not
+        // be a string takes strdec.encodingValue, which formats the error
+        // with %s. Omitted means utf8, Node's default.
         if (symbol && ts.symbolName(symbol) === "StringDecoder" && lowerer.isStdlibSymbol(symbol)) {
             const args = expr.arguments?.nodes ?? [];
             if (args.length > 1) {
@@ -9248,11 +9360,16 @@ export function lowerNew(lowerer, expr) {
                 : encT.isStringLiteralType()
                     ? knownBufEncoding(encT.value)
                     : undefined;
+            const textual = (type) => type.isUnionType()
+                ? ts.constituentTypes(type).every(textual)
+                : (type.flags &
+                    (ts.TypeFlags.StringLike | ts.TypeFlags.Undefined | ts.TypeFlags.Null)) !==
+                    0;
             const encoding = encName !== undefined
                 ? { kind: "strLit", value: encName, type: STRING, loc }
                 : {
                     kind: "libCall",
-                    fn: "strdec.encoding",
+                    fn: textual(encT) ? "strdec.encoding" : "strdec.encodingValue",
                     args: [lowerer.lowerExprExpecting(encNode, DYN)],
                     type: STRING,
                     loc,
@@ -9357,10 +9474,10 @@ export function lowerNew(lowerer, expr) {
             }
             else if (mapped?.kind !== "map" || contextualSeed) {
                 const ctx = lowerer.checker.getContextualType(expr);
-                const ctxMapped = ctx ? lowerer.mapTypeOf(ctx) : null;
-                if (ctx && ctxMapped?.kind === "map") {
+                const ctxMap = ctx ? contextualMapLayout(lowerer, ctx) : null;
+                if (ctx && ctxMap !== null) {
                     tsType = ctx;
-                    mapped = ctxMapped;
+                    mapped = ctxMap;
                 }
             }
             // `new Map(source)` the checker types `Map<any, any>` because the