@defold-typescript/types 0.52.0 → 0.54.0

package/src/emit-dts.ts

@@ -15,7 +15,7 @@ import type {
   ApiTypedef,
   ApiVariable,
 } from "./api-doc";
-import { DEFOLD_TYPE_MAP } from "./core-types";
+import { DEFOLD_TYPE_MAP, SOCKET_HANDLE_NAMES, type SocketHandleReceiver } from "./core-types";
 import { correctionPins, pinMatches, propertyCorrectionPins } from "./correction-pins";
 import {
   type DocCommentParts,
@@ -26,6 +26,7 @@ import {
   summaryFor,
 } from "./doc-comment";
 import { applyMessageOverlays, parseMessagesDoc } from "./emit-messages";
+import { engineTypeName } from "./engine-type-name";
 import type { TranslationStore } from "./example-store";
 import { lookupExampleSegments, translateProseFences } from "./example-store";
 import {
@@ -73,6 +74,11 @@ export interface EmitOptions {
   // map; a library or extension declaration passes its page keys (`[]` for one
   // no page documents), so it never names Defold as the receiver.
   indexBaseSource?: IndexBaseSource;
+  // Whether the module declares the `CONSTANT_UNION_ALIASES` rows homed in its
+  // namespace. Defaults to `true`; an extension declaring an engine namespace
+  // passes `false`, so it never re-declares an alias the engine module already
+  // declares, while its signatures still spell `gui.Playback`.
+  ownsConstantUnionAliases?: boolean;
   // The TS path of each `ENUM`, `STRUCT` and `TYPEDEF` another module declares
   // (`declaredTypePaths`), so a token naming one resolves instead of widening to
   // `unknown`. The module's own declarations resolve without it. Read only by the
@@ -87,9 +93,10 @@ export interface EmitOptions {
   // bindings (a ref-doc target), where every entry the ref-doc omits is emitted.
   registeredConstants?: ReadonlySet<string>;
   // The `RETURN_TYPE_CORRECTIONS` and `STRUCT_MEMBER_ADDITIONS` keys whose binding
-  // pin holds in the target's vendored engine source. A binding-pinned entry
-  // applies only when its key is here, so a surface with no vendored bindings
-  // (absent) applies none of them.
+  // pin holds in the target's vendored engine source, and the
+  // `PROPERTY_KEY_RANGES` keys whose `engine` pins all hold there. A pinned
+  // entry applies only when its key is here, so a surface with no vendored
+  // bindings (absent) applies none of them.
   bindingEvidence?: ReadonlySet<string>;
   // The 1-based parameter slots, keyed by function FQN, that the target's engine
   // bindings let a call omit but raise on when passed nil. Each optional one
@@ -203,9 +210,10 @@ export const ARBITRARY_TABLE_SLOTS = new Set([
   // crash.get_modules is "module table".
   "crash.get_backtrace",
   "crash.get_modules",
-  // platform-specific options: the doc is a dead backtick-prose cross-ref to a
-  // sibling whose function is absent from the fixture (webview.open is not
-  // documented), so no machine-readable shape exists.
+  // platform-specific options: the doc is a backtick-prose cross-ref to
+  // webview.open, whose options are documented as structured `.script_api`
+  // fields rather than a prose field list, so the cross-reference resolver (which
+  // reads a sibling's prose only) finds no machine-readable shape here.
   "webview.open_raw",
   // OS-resolver returns: the shape is set by the host resolver, not Defold's
   // API contract; each fixture doc reads "a table with all information
@@ -554,7 +562,7 @@ export const RETURN_TYPE_CORRECTIONS: ReadonlyMap<string, ReturnTypeCorrection>
   [
     "bullet3d.shape.get_shape",
     {
-      ts: "bullet3d.shape.definition | { type: typeof bullet3d.shape.SHAPE_TYPE_MESH }",
+      ts: "bullet3d.shape.Definition | { type: typeof bullet3d.shape.SHAPE_TYPE_MESH }",
       upstream: ["bullet3d.shape.definition"],
       reason:
         "script_bullet3d_shape.cpp:Shape_GetShape sets only `type` for a triangle mesh, which no shape definition arm matches",
@@ -658,6 +666,36 @@ export const RETURN_TYPE_CORRECTIONS: ReadonlyMap<string, ReturnTypeCorrection>
         },
       ] as const,
   ),
+  [
+    "gui.get_xanchor",
+    {
+      ts: "Exclude<gui.Anchor, typeof gui.ANCHOR_BOTTOM | typeof gui.ANCHOR_TOP>",
+      upstream: ["constant"],
+      retypedUpstream: [["gui.ANCHOR"]],
+      reason:
+        "gui_script.cpp:LuaGetXAnchor pushes GetNodeXAnchor, an x anchor: XANCHOR_NONE, XANCHOR_LEFT, or XANCHOR_RIGHT",
+      binding: {
+        file: "gui/src/gui_script.cpp",
+        cFunction: "LuaGetXAnchor",
+        contains: "lua_pushnumber(L, GetNodeXAnchor(scene, hnode));",
+      },
+    },
+  ],
+  [
+    "gui.get_yanchor",
+    {
+      ts: "Exclude<gui.Anchor, typeof gui.ANCHOR_LEFT | typeof gui.ANCHOR_RIGHT>",
+      upstream: ["constant"],
+      retypedUpstream: [["gui.ANCHOR"]],
+      reason:
+        "gui_script.cpp:LuaGetYAnchor pushes GetNodeYAnchor, a y anchor: YANCHOR_NONE, YANCHOR_TOP, or YANCHOR_BOTTOM",
+      binding: {
+        file: "gui/src/gui_script.cpp",
+        cFunction: "LuaGetYAnchor",
+        contains: "lua_pushnumber(L, GetNodeYAnchor(scene, hnode));",
+      },
+    },
+  ],
 ]);
 
 // A parameter whose declared `types` disagree with what the same element's
@@ -665,23 +703,29 @@ export const RETURN_TYPE_CORRECTIONS: ReadonlyMap<string, ReturnTypeCorrection>
 // target by resource name, a texture unit, a Lua sequence where `table` is
 // declared, a hash the binding refuses as a string. Admission rule: only a slot
 // that evidence contradicts; a slot that is merely imprecise is not a candidate.
-// The correction edits the mapped union rather than replacing it: `adds` appends
-// what the slot also takes and `removes` drops members the binding raises on, so
-// the URL address alias, array curation and constant mapping stay live, and
-// optionality stays with `isDocOptional`. Each entry records the upstream tokens
-// it contradicts, plus any later spelling of the same defect in
-// `retypedUpstream`, and applies only to a slot still declaring one of them;
-// `param-correction-provenance.test.ts` pins them against every retained
-// vendored ref-doc. Once no retained target still declares any of them the
-// entry is deleted, never re-pinned.
-export interface ParamTypeCorrection {
-  readonly adds?: string;
-  readonly removes?: readonly string[];
+// A correction either replaces the mapped type exactly with `ts`, or edits the
+// mapped union: `adds` appends what the slot also takes and `removes` drops
+// members the binding raises on. Union edits keep the URL address alias, array
+// curation and constant mapping live; optionality stays with `isDocOptional`.
+// Each entry records the upstream tokens it contradicts, plus any later spelling
+// of the same defect in `retypedUpstream`, and applies only to a slot still
+// declaring one of them. An entry with a `binding` also requires its exact
+// `EmitOptions.bindingEvidence` key. `param-correction-provenance.test.ts` pins
+// the ref-doc tokens against every retained target; once no target declares a
+// pin, the entry is deleted rather than re-pinned.
+interface ParamTypeCorrectionBase {
   readonly upstream: readonly string[];
   readonly retypedUpstream?: readonly (readonly string[])[];
   readonly reason: string;
+  readonly binding?: BindingPin;
 }
 
+export type ParamTypeCorrection = ParamTypeCorrectionBase &
+  (
+    | { readonly ts: string; readonly adds?: undefined; readonly removes?: undefined }
+    | { readonly ts?: undefined; readonly adds?: string; readonly removes?: readonly string[] }
+  );
+
 const CAMERA_ADDRESS_REASON =
   "render_script_camera.cpp:CheckRenderCamera resolves anything but a number handle through ResolveURL, which takes a string or a hash";
 
@@ -715,6 +759,58 @@ export const PARAM_TYPE_CORRECTIONS: ReadonlyMap<string, ParamTypeCorrection> =
   string,
   ParamTypeCorrection
 >([
+  [
+    "gui.set_xanchor:param:anchor",
+    {
+      ts: "Exclude<gui.Anchor, typeof gui.ANCHOR_BOTTOM | typeof gui.ANCHOR_TOP>",
+      upstream: ["constant"],
+      retypedUpstream: [["gui.ANCHOR"]],
+      reason:
+        "gui_script.cpp:LuaSetXAnchor rejects every value except XANCHOR_NONE, XANCHOR_LEFT, and XANCHOR_RIGHT",
+      binding: {
+        file: "gui/src/gui_script.cpp",
+        cFunction: "LuaSetXAnchor",
+        contains: "anchor != XANCHOR_NONE && anchor != XANCHOR_LEFT && anchor != XANCHOR_RIGHT",
+      },
+    },
+  ],
+  [
+    "gui.set_yanchor:param:anchor",
+    {
+      ts: "Exclude<gui.Anchor, typeof gui.ANCHOR_LEFT | typeof gui.ANCHOR_RIGHT>",
+      upstream: ["constant"],
+      retypedUpstream: [["gui.ANCHOR"]],
+      reason:
+        "gui_script.cpp:LuaSetYAnchor rejects every value except YANCHOR_NONE, YANCHOR_TOP, and YANCHOR_BOTTOM",
+      binding: {
+        file: "gui/src/gui_script.cpp",
+        cFunction: "LuaSetYAnchor",
+        contains: "anchor != YANCHOR_NONE && anchor != YANCHOR_TOP && anchor != YANCHOR_BOTTOM",
+      },
+    },
+  ],
+  [
+    "go.animate:param:playback",
+    {
+      ts: "go.Playback",
+      upstream: [
+        "go.PLAYBACK_ONCE_FORWARD",
+        "go.PLAYBACK_ONCE_BACKWARD",
+        "go.PLAYBACK_ONCE_PINGPONG",
+        "go.PLAYBACK_LOOP_FORWARD",
+        "go.PLAYBACK_LOOP_BACKWARD",
+        "go.PLAYBACK_LOOP_PINGPONG",
+      ],
+      retypedUpstream: [["go.PLAYBACK"]],
+      reason:
+        "gameobject_script.cpp:Script_Animate accepts every playback value below PLAYBACK_COUNT, including PLAYBACK_NONE",
+      binding: {
+        file: "gameobject/src/gameobject/gameobject_script.cpp",
+        cFunction: "Script_Animate",
+        contains: "if (playback >= PLAYBACK_COUNT)",
+      },
+    },
+  ],
   ...CAMERA_SLOT_FUNCTIONS.map(
     (name) =>
       [
@@ -921,8 +1017,8 @@ export const PARAM_TYPE_CORRECTIONS: ReadonlyMap<string, ParamTypeCorrection> =
       [
         `render.${name}:param:state`,
         {
-          adds: "graphics.State",
-          removes: ["graphics.STATE"],
+          adds: "Exclude<graphics.State, typeof graphics.STATE_ALPHA_TEST_SUPPORTED | typeof graphics.STATE_SCISSOR_TEST>",
+          removes: ["graphics.State"],
           upstream: ["graphics.STATE"],
           reason: `render_script.cpp:RenderScript_${name === "enable_state" ? "Enable" : "Disable"}State raises "Invalid state" on any state but the six it lists, so graphics.STATE_SCISSOR_TEST and graphics.STATE_ALPHA_TEST_SUPPORTED are rejected`,
         },
@@ -997,8 +1093,8 @@ export const PARAM_TYPE_CORRECTIONS: ReadonlyMap<string, ParamTypeCorrection> =
   [
     "window.set_dim_mode:param:mode",
     {
-      removes: ["window.DIMMING"],
-      adds: "window.DimModeStateSettable",
+      removes: ["window.Dimming"],
+      adds: "Exclude<window.Dimming, typeof window.DIMMING_UNKNOWN>",
       upstream: ["window.DIMMING"],
       reason:
         'script_window.cpp:SetDimMode raises "The dim mode specified is not supported." for anything but DIMMING_ON and DIMMING_OFF',
@@ -1100,16 +1196,70 @@ export const PROPERTY_TYPE_CORRECTIONS: ReadonlyMap<string, PropertyTypeCorrecti
 // saying it, or when the phrase stops stating `first-last`. Curated rather than
 // matched on a trailing `N`, so each new upstream placeholder is a deliberate
 // addition.
+//
+// `engine.last` replaces `last` on a target whose vendored engine source shows
+// every one of `engine.pins` (the `EmitOptions.bindingEvidence` keys); every
+// other surface, including one generated from a ref-doc alone, keeps the range
+// `evidence` states.
 export interface PropertyKeyRange {
   readonly prefix: string;
   readonly first: number;
   readonly last: number;
   readonly evidence: string;
+  readonly engine?: { readonly last: number; readonly pins: readonly EngineSourcePin[] };
 }
 
-// Keyed `<namespace>.<property>`, mirroring PROPERTY_TYPE_CORRECTIONS.
+// A token snippet the target's vendored engine evidence must contain. With
+// `cFunction` it is matched in that function's body, without it anywhere in
+// the file.
+export interface EngineSourcePin {
+  // Relative to the target's vendored `engine/` tree, as `BindingPin.file` is.
+  readonly file: string;
+  readonly cFunction?: string;
+  readonly contains: string;
+}
+
+const MODEL_TEXTURE_LOOP =
+  "for (uint32_t i = 0; i < dmRender::RenderObject::MAX_TEXTURE_COUNT; ++i) { if (params.m_PropertyId == PROP_TEXTURE[i])";
+
+// Keyed `<namespace>.<property>`, mirroring PROPERTY_TYPE_CORRECTIONS; a key
+// with an `engine` field is also an `EmitOptions.bindingEvidence` key.
 export const PROPERTY_KEY_RANGES: ReadonlyMap<string, PropertyKeyRange> = new Map([
-  ["model.textureN", { prefix: "texture", first: 0, last: 7, evidence: "textureN where N is 0-7" }],
+  [
+    "model.textureN",
+    {
+      prefix: "texture",
+      first: 0,
+      last: 7,
+      evidence: "textureN where N is 0-7",
+      engine: {
+        last: 15,
+        pins: [
+          {
+            file: "render/src/dmsdk/render/render.h",
+            contains: "static const uint32_t MAX_TEXTURE_COUNT = 16;",
+          },
+          {
+            file: "gamesys/src/gamesys/gamesys.cpp",
+            contains: `const dmhash_t PROP_TEXTURE[dmRender::RenderObject::MAX_TEXTURE_COUNT] = { ${Array.from(
+              { length: 16 },
+              (_, unit) => `dmHashString64("texture${unit}"),`,
+            ).join(" ")} };`,
+          },
+          {
+            file: "gamesys/src/gamesys/components/comp_model.cpp",
+            cFunction: "CompModelGetProperty",
+            contains: MODEL_TEXTURE_LOOP,
+          },
+          {
+            file: "gamesys/src/gamesys/components/comp_model.cpp",
+            cFunction: "CompModelSetProperty",
+            contains: MODEL_TEXTURE_LOOP,
+          },
+        ],
+      },
+    },
+  ],
 ]);
 
 // A parameter the ref-doc metadata marks required while the same element's prose
@@ -1763,13 +1913,9 @@ export const CONSTANT_SLOT_RESOLUTIONS: ReadonlyMap<string, ConstantSlotResoluti
   ],
   ["gui.new_texture:param:type", { residual: "the doc lists texture type strings only" }],
   ["gui.set_texture_data:param:type", { residual: "the doc lists texture type strings only" }],
-  [
-    "iap.get_provider_id:return:provider_id",
-    { residual: "the doc names iap.PROVIDER_ID_*, which no ref-doc defines as a constant" },
-  ],
 ]);
 
-export interface ConstantUnionAlias {
+export interface ConstantUnionNamedRow {
   // The namespace the alias is declared in. It is the namespace the union
   // *means*, which is not always the one its constants live in: the three
   // buffer keys `render.clear` accepts are `graphics.BUFFER_TYPE_*` constants,
@@ -1780,11 +1926,22 @@ export interface ConstantUnionAlias {
   readonly members: readonly string[];
 }
 
-// A documented constant union gets a public name so a caller can spell the type
-// their own wrapper takes. Identity is the *member set*, never a name prefix:
-// `gui.ANCHOR_*` splits into two rows because the x and y slots accept
-// different thirds of it, and `graphics.BUFFER_TYPE_*` splits because
-// `render.clear` accepts three of the six.
+// A union that is a strict subset of a named row in the same home. It declares
+// nothing: each slot spells it `Exclude<<home>.<parent>, ...>`, so one namespace
+// never carries two names for overlapping sets.
+export interface ConstantUnionSubsetRow {
+  readonly home: string;
+  readonly parent: string;
+  readonly members: readonly string[];
+}
+
+export type ConstantUnionAlias = ConstantUnionNamedRow | ConstantUnionSubsetRow;
+
+// A documented constant union gets a public spelling so a caller can write the
+// type their own wrapper takes. Identity is the *member set*, never a name
+// prefix: the x and y anchor slots accept different thirds of `gui.ANCHOR_*`,
+// so each is its own subset row of `gui.ANCHOR`, and `graphics.BUFFER_TYPE_*`
+// splits because `render.clear` accepts three of the six.
 //
 // The table is the only thing the emitter reads, and every name in it has been
 // reviewed: a longest-common-prefix rule proposes, a human disposes. A union
@@ -1794,7 +1951,7 @@ export interface ConstantUnionAlias {
 export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   {
     home: "buffer",
-    name: "ValueType",
+    name: "VALUE_TYPE",
     members: [
       "buffer.VALUE_TYPE_FLOAT32",
       "buffer.VALUE_TYPE_INT16",
@@ -1809,7 +1966,7 @@ export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   },
   {
     home: "collectionfactory",
-    name: "Status",
+    name: "STATUS",
     members: [
       "collectionfactory.STATUS_UNLOADED",
       "collectionfactory.STATUS_LOADING",
@@ -1818,12 +1975,12 @@ export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   },
   {
     home: "factory",
-    name: "Status",
+    name: "STATUS",
     members: ["factory.STATUS_UNLOADED", "factory.STATUS_LOADING", "factory.STATUS_LOADED"],
   },
   {
     home: "go",
-    name: "Easing",
+    name: "EASING",
     members: [
       "go.EASING_INBACK",
       "go.EASING_INBOUNCE",
@@ -1870,7 +2027,20 @@ export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   },
   {
     home: "go",
-    name: "Playback",
+    name: "PLAYBACK",
+    members: [
+      "go.PLAYBACK_LOOP_BACKWARD",
+      "go.PLAYBACK_LOOP_FORWARD",
+      "go.PLAYBACK_LOOP_PINGPONG",
+      "go.PLAYBACK_NONE",
+      "go.PLAYBACK_ONCE_BACKWARD",
+      "go.PLAYBACK_ONCE_FORWARD",
+      "go.PLAYBACK_ONCE_PINGPONG",
+    ],
+  },
+  {
+    home: "go",
+    parent: "PLAYBACK",
     members: [
       "go.PLAYBACK_ONCE_FORWARD",
       "go.PLAYBACK_ONCE_BACKWARD",
@@ -1884,7 +2054,7 @@ export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   // target defines the constants; only the newer ones name the union.
   {
     home: "graphics",
-    name: "BlendFactor",
+    name: "BLEND_FACTOR",
     members: [
       "graphics.BLEND_FACTOR_ZERO",
       "graphics.BLEND_FACTOR_ONE",
@@ -1905,7 +2075,7 @@ export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   },
   {
     home: "graphics",
-    name: "BufferType",
+    name: "BUFFER_TYPE",
     members: [
       "graphics.BUFFER_TYPE_COLOR0_BIT",
       "graphics.BUFFER_TYPE_COLOR1_BIT",
@@ -1917,7 +2087,22 @@ export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   },
   {
     home: "graphics",
-    name: "State",
+    name: "STATE",
+    members: [
+      "graphics.STATE_ALPHA_TEST",
+      "graphics.STATE_ALPHA_TEST_SUPPORTED",
+      "graphics.STATE_BLEND",
+      "graphics.STATE_CULL_FACE",
+      "graphics.STATE_DEPTH_TEST",
+      "graphics.STATE_POLYGON_OFFSET_FILL",
+      "graphics.STATE_SCISSOR_TEST",
+      "graphics.STATE_STENCIL_TEST",
+    ],
+  },
+  // The six render_script.cpp:RenderScript_EnableState accepts.
+  {
+    home: "graphics",
+    parent: "STATE",
     members: [
       "graphics.STATE_DEPTH_TEST",
       "graphics.STATE_STENCIL_TEST",
@@ -1929,12 +2114,33 @@ export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   },
   {
     home: "gui",
-    name: "AdjustMode",
+    name: "ADJUST",
     members: ["gui.ADJUST_FIT", "gui.ADJUST_ZOOM", "gui.ADJUST_STRETCH"],
   },
   {
     home: "gui",
-    name: "BlendMode",
+    name: "ANCHOR",
+    members: [
+      "gui.ANCHOR_BOTTOM",
+      "gui.ANCHOR_LEFT",
+      "gui.ANCHOR_NONE",
+      "gui.ANCHOR_RIGHT",
+      "gui.ANCHOR_TOP",
+    ],
+  },
+  {
+    home: "gui",
+    parent: "ANCHOR",
+    members: ["gui.ANCHOR_NONE", "gui.ANCHOR_LEFT", "gui.ANCHOR_RIGHT"],
+  },
+  {
+    home: "gui",
+    parent: "ANCHOR",
+    members: ["gui.ANCHOR_NONE", "gui.ANCHOR_TOP", "gui.ANCHOR_BOTTOM"],
+  },
+  {
+    home: "gui",
+    name: "BLEND",
     members: [
       "gui.BLEND_ALPHA",
       "gui.BLEND_ADD",
@@ -1945,12 +2151,12 @@ export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   },
   {
     home: "gui",
-    name: "ClippingMode",
+    name: "CLIPPING_MODE",
     members: ["gui.CLIPPING_MODE_NONE", "gui.CLIPPING_MODE_STENCIL"],
   },
   {
     home: "gui",
-    name: "Easing",
+    name: "EASING",
     members: [
       "gui.EASING_INBACK",
       "gui.EASING_INBOUNCE",
@@ -1997,7 +2203,7 @@ export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   },
   {
     home: "gui",
-    name: "KeyboardType",
+    name: "KEYBOARD_TYPE",
     members: [
       "gui.KEYBOARD_TYPE_DEFAULT",
       "gui.KEYBOARD_TYPE_EMAIL",
@@ -2007,7 +2213,7 @@ export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   },
   {
     home: "gui",
-    name: "NodeType",
+    name: "TYPE",
     members: [
       "gui.TYPE_BOX",
       "gui.TYPE_TEXT",
@@ -2018,12 +2224,12 @@ export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   },
   {
     home: "gui",
-    name: "PieBounds",
+    name: "PIEBOUNDS",
     members: ["gui.PIEBOUNDS_RECTANGLE", "gui.PIEBOUNDS_ELLIPSE"],
   },
   {
     home: "gui",
-    name: "Pivot",
+    name: "PIVOT",
     members: [
       "gui.PIVOT_CENTER",
       "gui.PIVOT_N",
@@ -2038,7 +2244,7 @@ export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   },
   {
     home: "gui",
-    name: "Playback",
+    name: "PLAYBACK",
     members: [
       "gui.PLAYBACK_ONCE_FORWARD",
       "gui.PLAYBACK_ONCE_BACKWARD",
@@ -2050,7 +2256,7 @@ export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   },
   {
     home: "gui",
-    name: "Property",
+    name: "PROP",
     members: [
       "gui.PROP_POSITION",
       "gui.PROP_ROTATION",
@@ -2069,7 +2275,7 @@ export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   },
   {
     home: "gui",
-    name: "SafeAreaMode",
+    name: "SAFE_AREA",
     members: [
       "gui.SAFE_AREA_NONE",
       "gui.SAFE_AREA_LONG",
@@ -2079,22 +2285,12 @@ export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   },
   {
     home: "gui",
-    name: "SizeMode",
+    name: "SIZE_MODE",
     members: ["gui.SIZE_MODE_MANUAL", "gui.SIZE_MODE_AUTO"],
   },
-  {
-    home: "gui",
-    name: "XAnchor",
-    members: ["gui.ANCHOR_NONE", "gui.ANCHOR_LEFT", "gui.ANCHOR_RIGHT"],
-  },
-  {
-    home: "gui",
-    name: "YAnchor",
-    members: ["gui.ANCHOR_NONE", "gui.ANCHOR_TOP", "gui.ANCHOR_BOTTOM"],
-  },
   {
     home: "profiler",
-    name: "Mode",
+    name: "MODE",
     members: [
       "profiler.MODE_RUN",
       "profiler.MODE_PAUSE",
@@ -2104,7 +2300,7 @@ export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   },
   {
     home: "profiler",
-    name: "ViewMode",
+    name: "VIEW_MODE",
     members: ["profiler.VIEW_MODE_FULL", "profiler.VIEW_MODE_MINIMIZED"],
   },
   {
@@ -2124,7 +2320,7 @@ export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   },
   {
     home: "sys",
-    name: "NetworkConnectivity",
+    name: "NETWORK",
     members: [
       "sys.NETWORK_DISCONNECTED",
       "sys.NETWORK_CONNECTED_CELLULAR",
@@ -2133,12 +2329,12 @@ export const CONSTANT_UNION_ALIASES: readonly ConstantUnionAlias[] = [
   },
   {
     home: "window",
-    name: "DimModeState",
+    name: "DIMMING",
     members: ["window.DIMMING_UNKNOWN", "window.DIMMING_ON", "window.DIMMING_OFF"],
   },
   {
     home: "window",
-    name: "DimModeStateSettable",
+    parent: "DIMMING",
     members: ["window.DIMMING_ON", "window.DIMMING_OFF"],
   },
 ];
@@ -2158,11 +2354,47 @@ export function constantUnionAlias(fqns: readonly string[]): ConstantUnionAlias
   return CONSTANT_UNION_ALIAS_BY_MEMBERS.get(constantUnionAliasKey(fqns));
 }
 
-// The alias declarations a module owns, in name order. A row is declared in its
-// home whether or not that module references it, so a cross-namespace row is
-// reachable from the module whose signatures spell it.
-export function constantUnionAliasDeclarations(namespace: string): string[] {
-  return CONSTANT_UNION_ALIASES.filter((row) => row.home === namespace)
+// What a slot taking exactly the row's members is written as: a named row's
+// qualified name, or a subset row's parent minus the parent's other members,
+// listed in the parent's order.
+export function constantUnionSpelling(row: ConstantUnionAlias): string {
+  if ("name" in row) return `${row.home}.${engineTypeName(row.name)}`;
+  const parent = CONSTANT_UNION_ALIASES.find(
+    (candidate): candidate is ConstantUnionNamedRow =>
+      "name" in candidate && candidate.home === row.home && candidate.name === row.parent,
+  );
+  if (parent === undefined) {
+    throw new Error(`constant union subset of ${row.home}.${row.parent}: no such named row`);
+  }
+  const kept = new Set(row.members);
+  const excluded = parent.members.filter((member) => !kept.has(member));
+  return `Exclude<${row.home}.${engineTypeName(row.parent)}, ${excluded.map((m) => `typeof ${m}`).join(" | ")}>`;
+}
+
+// The named rows a module owns; a subset row declares nothing. A row is
+// declared in its home whether or not that module references it, so a
+// cross-namespace row is reachable from the module whose signatures spell it.
+// A row whose name the module's own `ENUM` already declares is left to that
+// `ENUM`, which carries the reference's member order and nilable arms. An
+// extension module is never a row's home, even when it declares the engine
+// namespace (`gui`), so its emit skips this (`ownsConstantUnionAliases`).
+function ownedConstantUnionAliases(
+  namespace: string,
+  enumDeclared: ReadonlySet<string>,
+): ConstantUnionNamedRow[] {
+  return CONSTANT_UNION_ALIASES.filter(
+    (row): row is ConstantUnionNamedRow =>
+      "name" in row && row.home === namespace && !enumDeclared.has(row.name),
+  );
+}
+
+// The alias declarations a module owns, in name order.
+export function constantUnionAliasDeclarations(
+  namespace: string,
+  enumDeclared: ReadonlySet<string> = new Set(),
+): string[] {
+  return ownedConstantUnionAliases(namespace, enumDeclared)
+    .map((row) => ({ name: engineTypeName(row.name), members: row.members }))
     .sort((a, b) => a.name.localeCompare(b.name))
     .map((row) => unionAliasDeclaration(row.name, row.members));
 }
@@ -2178,10 +2410,12 @@ function unionAliasDeclaration(
 }
 
 // A slot of a function the authored-overload lane declares, published under
-// one alias on every target so the version-independent overload file can
-// name the type each target's own reference gives that slot.
+// one name on every target so the version-independent overload file can name
+// the type each target's own reference gives that slot. The name is the
+// PascalCase name of the newest reference's own declaration for the slot; a
+// target that declares it emits no alias.
 export const OVERLOAD_SLOT_ALIASES: ReadonlyMap<string, string> = new Map([
-  ["render.render_target:param:parameters", "RenderTargetParams"],
+  ["render.render_target:param:parameters", engineTypeName("render_target_params")],
 ]);
 
 const DOC_CONSTANT_TOKEN =
@@ -2358,9 +2592,9 @@ export const HOMOGENEOUS_ARRAY_SLOTS: ReadonlyMap<string, string | readonly stri
   ["iap.list", "string"],
   // push.register's `notifications` is a prose-only array of push.NOTIFICATION_*
   // bitmask constants (the ref example sums NOTIFICATION_BADGE/SOUND/ALERT). The
-  // vendored push_doc.json fixture declares no NOTIFICATION_* constant elements, so
-  // no brand exists to reference; `number` is the faithful element token for these
-  // numeric constants, mirroring the vmath.vector/buffer.* number entries.
+  // slot's prose names no constant the expansion could read, and a summed bitmask
+  // is a plain number rather than any one brand, so `number` is the faithful
+  // element token, mirroring the vmath.vector/buffer.* number entries.
   ["push.register", "number"],
   // camera.get_cameras returns "a table with all camera URLs" (the ref example
   // iterates it with `pairs`) — a homogeneous list of `url`, emitted `Url[]`.
@@ -2395,7 +2629,34 @@ export type TableSlotCuration = (
   | { kind: "verbatim"; ts: string }
 ) & { readonly retypedUpstream?: readonly string[] };
 
-export const SOCKET_HANDLE_TOKENS = ["client", "master", "unconnected"] as const;
+// The interface a module's component properties are declared on; its PROPERTY
+// entries carry its members, so it signs no TYPEDEF of its own.
+export const PROPERTIES_INTERFACE = engineTypeName("properties");
+
+// The ref-doc tokens of the handles `socket.select` takes and returns, in their
+// 1.13.2 TYPEDEF spelling, which the type map resolves to each handle's interface.
+export const SOCKET_HANDLE_TOKENS = (["client", "master", "unconnected"] as const).map(
+  (receiver) => `socket_${receiver}`,
+);
+
+// The interface a module's `<receiver>:<method>` colon methods are emitted on:
+// the socket handles take their `Socket<Receiver>` name, any other receiver
+// keeps its own.
+export function handleInterfaceName(namespace: string, receiver: string): string {
+  return namespace === "socket" && Object.hasOwn(SOCKET_HANDLE_NAMES, receiver)
+    ? SOCKET_HANDLE_NAMES[receiver as SocketHandleReceiver]
+    : receiver;
+}
+
+// The typedef names a module's handle interfaces stand for, which emit as the
+// interface rather than an alias: each receiver (1.13.1 `client`) and each
+// interface name, which the 1.13.2 `socket_client` takes once renamed
+// (`SocketClient`).
+function handleTypedefNames(namespace: string, receivers: Iterable<string>): Set<string> {
+  return new Set(
+    [...receivers].flatMap((receiver) => [receiver, handleInterfaceName(namespace, receiver)]),
+  );
+}
 
 // Shared Box2D (b2d.*) table shapes, curated from the ref-doc prose (the docs
 // name fields in running text, not a machine-readable `<dl>`). Reused across the
@@ -3390,7 +3651,7 @@ export const CALLBACK_SIGNATURE_CURATIONS: ReadonlyMap<string, CallbackSignature
         "(self: unknown, event: (typeof window)[Extract<keyof typeof window, `WINDOW_EVENT_${string}`>], data: Record<string | number, unknown>) => void",
       typed:
         // biome-ignore lint/suspicious/noTemplateCurlyInString: emitted verbatim as a TS template literal type
-        "(self: unknown, event: (typeof window)[Extract<keyof typeof window, `WINDOW_EVENT_${string}`>], data: window.event_data) => void",
+        "(self: unknown, event: (typeof window)[Extract<keyof typeof window, `WINDOW_EVENT_${string}`>], data: window.EventData) => void",
     },
   ],
   [
@@ -3458,9 +3719,11 @@ export const NESTED_FIELD_CURATIONS: ReadonlyMap<string, readonly TableField[]>
 // `<element>:<kind>:<slot>:<field>`, mirroring NESTED_FIELD_CURATIONS; a field
 // one level down is `<field>.<member>`, or `<field>[].<member>` inside a list.
 //
-// The atlas animation `playback` field is documented as `constant` with the
-// prose "the default value is go.PLAYBACK_ONCE_FORWARD", which names the enum
-// the bare token cannot.
+// Unpinned records below rest on ref-doc tokens or prose. The atlas animation
+// `playback` field is documented as `constant` with the prose "the default value
+// is go.PLAYBACK_ONCE_FORWARD", which names the enum the bare token cannot; its
+// records also carry engine binding pins and apply only when the matching
+// `EmitOptions.bindingEvidence` key holds for the target.
 //
 // `gui.set`'s `options.key` is documented as `hash`, while upstream's own
 // example sets a named font with `{ key = "my_font_name" }`.
@@ -3473,21 +3736,47 @@ export const NESTED_FIELD_CURATIONS: ReadonlyMap<string, readonly TableField[]>
 // script_resource.cpp:CreateSoundData reads it with CheckBufferOrString.
 const CONSTANT_VALUE_TS = "Vector4 | Vector3 | Matrix4 | number | (Vector4 | Matrix4)[]";
 const ATTRIBUTE_VALUE_TS = "Vector4 | Vector3 | Matrix4 | number | number[]";
-export const TABLE_FIELD_TYPE_OVERRIDES: ReadonlyMap<string, string> = new Map([
-  ["compute.set_constants:param:constants:value", CONSTANT_VALUE_TS],
-  ["material.set_constants:param:constants:value", CONSTANT_VALUE_TS],
-  ["material.set_vertex_attributes:param:attributes:value", ATTRIBUTE_VALUE_TS],
-  ["material.get_vertex_attributes:return:table:value", ATTRIBUTE_VALUE_TS],
-  ["resource.set_atlas:param:table:animations[].playback", "go.Playback"],
-  ["resource.create_atlas:param:table:animations[].playback", "go.Playback"],
-  ["resource.get_atlas:return:data:animations[].playback", "go.Playback"],
-  ["render.set_render_target:param:options:transient", "graphics.BufferType[]"],
-  ["resource.create_sound_data:param:options:data", 'string | Opaque<"buffer">'],
+const ATLAS_BINDING_FILE = "gamesys/src/gamesys/scripts/script_resource.cpp";
+const ATLAS_INPUT_PLAYBACK_BINDING: BindingPin = {
+  file: ATLAS_BINDING_FILE,
+  cFunction: "MakeTextureSetFromLua",
+  contains: "GameObjectPlaybackToDDFPlayback((dmGameObject::Playback) lua_tointeger(L,-1))",
+};
+const ATLAS_OUTPUT_PLAYBACK_BINDING: BindingPin = {
+  file: ATLAS_BINDING_FILE,
+  cFunction: "GetAtlas",
+  contains: "(lua_Integer) DDFPlaybackToGameObjectPlayback(anim.m_Playback)",
+};
+
+export interface TableFieldTypeOverride {
+  readonly ts: string;
+  readonly binding?: BindingPin;
+}
+
+export const TABLE_FIELD_TYPE_OVERRIDES: ReadonlyMap<string, TableFieldTypeOverride> = new Map([
+  ["compute.set_constants:param:constants:value", { ts: CONSTANT_VALUE_TS }],
+  ["material.set_constants:param:constants:value", { ts: CONSTANT_VALUE_TS }],
+  ["material.set_vertex_attributes:param:attributes:value", { ts: ATTRIBUTE_VALUE_TS }],
+  ["material.get_vertex_attributes:return:table:value", { ts: ATTRIBUTE_VALUE_TS }],
+  [
+    "resource.set_atlas:param:table:animations[].playback",
+    { ts: "go.Playback", binding: ATLAS_INPUT_PLAYBACK_BINDING },
+  ],
+  [
+    "resource.create_atlas:param:table:animations[].playback",
+    { ts: "go.Playback", binding: ATLAS_INPUT_PLAYBACK_BINDING },
+  ],
+  [
+    "resource.get_atlas:return:data:animations[].playback",
+    { ts: "go.Playback", binding: ATLAS_OUTPUT_PLAYBACK_BINDING },
+  ],
+  ["render.set_render_target:param:options:transient", { ts: "graphics.BufferType[]" }],
+  ["resource.create_sound_data:param:options:data", { ts: 'string | Opaque<"buffer">' }],
   // The option bags 1.13.2 types as a STRUCT, whose members still carry the
   // narrower upstream types: `gui.set`'s (its slot is declared in
   // gui-overloads.d.ts) and `resource.create_sound_data`'s.
-  ["gui.set_options:member:key", "string | Hash"],
-  ["resource.sound_data_options:member:data", 'string | Opaque<"buffer">'],
+  ["gui.set_options:member:key", { ts: "string | Hash" }],
+  ["resource.sound_data_options:member:data", { ts: 'string | Opaque<"buffer">' }],
   // Bitmasks typed as their flag enum: the create_texture example passes
   // TEXTURE_USAGE_FLAG_STORAGE + TEXTURE_USAGE_FLAG_SAMPLE, a sum no single member
   // names, and a reported value combines them the same way.
@@ -3498,13 +3787,15 @@ export const TABLE_FIELD_TYPE_OVERRIDES: ReadonlyMap<string, string> = new Map([
       "resource.render_target_attachment_info",
       "material.texture_info",
     ] as const
-  ).map((struct) => [`${struct}:member:flags`, "graphics.TEXTURE_USAGE_FLAG | number"] as const),
-  ["render.render_target_buffer_params:member:flags", "render.RENDER_TARGET_FLAG | number"],
+  ).map(
+    (struct) => [`${struct}:member:flags`, { ts: "graphics.TextureUsageFlag | number" }] as const,
+  ),
+  ["render.render_target_buffer_params:member:flags", { ts: "render.RenderTargetFlag | number" }],
   // gamesys_script.cpp:PushSampler, behind both get_samplers, pushes the raw
   // texture type; NormalizeBindableTextureType never runs there. A separate
   // sampler reports TEXTURE_TYPE_SAMPLER (6) and a separate texture binding one
   // of the four TEXTURE_TYPE_TEXTURE_* (7-10), none of which has a Lua constant.
-  ["material.sampler_info:member:type", "graphics.TEXTURE_TYPE | 6 | 7 | 8 | 9 | 10"],
+  ["material.sampler_info:member:type", { ts: "graphics.TextureType | 6 | 7 | 8 | 9 | 10" }],
 ]);
 
 // A field the engine accepts on an option bag whose `<dl>` upstream otherwise
@@ -3935,12 +4226,16 @@ export function applyFieldTypeOverrides(
   slotKind: "param" | "return" | undefined,
   slotName: string | undefined,
   fields: readonly TableField[],
+  bindingEvidence: ReadonlySet<string>,
 ): TableField[] {
   if (slotKind === undefined || slotName === undefined) return [...fields];
   const prefix = `${tableSlotKey(elementName, slotKind, slotName)}:`;
   const typed = (field: TableField, path: string): TableField => {
-    const override = TABLE_FIELD_TYPE_OVERRIDES.get(`${prefix}${path}`);
-    return override === undefined ? field : { ...field, tsType: override };
+    const key = `${prefix}${path}`;
+    const override = TABLE_FIELD_TYPE_OVERRIDES.get(key);
+    return override === undefined || (override.binding !== undefined && !bindingEvidence.has(key))
+      ? field
+      : { ...field, tsType: override.ts };
   };
   return fields.map((field) => {
     const own = typed(field, field.name);
@@ -4315,7 +4610,7 @@ export const TYPEDEF_ALIAS_CORRECTIONS: ReadonlyMap<string, TypedefAliasCorrecti
       upstream: [
         "{ type?:graphics.TEXTURE_TYPE, sample_count?:integer, [graphics.BUFFER_TYPE]:render.render_target_buffer_params }",
       ],
-      ts: "{ type?: render.RenderTargetTextureType; sample_count?: number } & { [key: number]: render.render_target_buffer_params }",
+      ts: "{ type?: render.RenderTargetTextureType; sample_count?: number } & { [key: number]: render.RenderTargetBufferParams }",
       reason:
         'render_script.cpp:RenderScript_RenderTarget raises "Invalid render target texture type" on any `type` but graphics.TEXTURE_TYPE_2D and graphics.TEXTURE_TYPE_CUBE_MAP',
     },
@@ -4344,15 +4639,17 @@ export const TYPEDEF_ALIAS_CORRECTIONS: ReadonlyMap<string, TypedefAliasCorrecti
 // function yields.
 //
 // An engine typedef that names its aliased type: a `userdata`/`number` handle the
-// type map resolves (`vector`, `socket_client`) aliases that mapping, an
+// type map resolves (`timer_handle`, `buffer_data`) aliases that mapping, an
 // unresolved one keeps the brand, and any other aliased type (a union, literals, a
-// record) aliases the type itself.
+// record) aliases the type itself. A handle the type map resolves to a core
+// global (`vector` -> `Vector`, `resource_data` -> `Hash`) declares nothing, since
+// its slots already name the global: `null`.
 function typedefAlias(
   typedef: ApiTypedef,
   local: string,
   rawMapType: (token: string) => string,
   mapType: DefoldTypeMapper,
-): string {
+): string | null {
   const brand = `Opaque<"${typedef.name}">`;
   const aliasOf = typedef.aliasOf ?? [];
   const correction = TYPEDEF_ALIAS_CORRECTIONS.get(typedef.name);
@@ -4371,10 +4668,23 @@ function typedefAlias(
   }
   const mapped = rawMapType(typedef.name);
   if (mapped.startsWith(brand)) return `type ${local} = ${mapped};`;
+  if (aliasOf.length > 0 && CORE_GLOBAL_TYPES.has(mapped)) return null;
   const resolved = aliasOf.length > 0 && mapped !== "unknown" && mapped !== local;
   return `type ${local} = ${resolved ? mapped : brand};`;
 }
 
+// The global types `core-types.ts` declares that the engine vocabulary maps a
+// handle to.
+const CORE_GLOBAL_TYPES: ReadonlySet<string> = new Set([
+  "Hash",
+  "Matrix4",
+  "Quaternion",
+  "Url",
+  "Vector",
+  "Vector3",
+  "Vector4",
+]);
+
 function isHandleAlias(aliasOf: readonly string[]): boolean {
   return aliasOf.length === 1 && (aliasOf[0] === "userdata" || aliasOf[0] === "number");
 }
@@ -4391,8 +4701,9 @@ interface TypeDeclaration {
 
 // A typedef with no aliased type keeps the flat-name rule it always had; one that
 // names its aliased type, and every struct, sits at its name less the module
-// prefix, nested when that local is dotted. Typedefs come before structs, each in
-// document order.
+// prefix, nested when that local is dotted. Every leaf goes through
+// `engineTypeName`, and `skip` matches a typedef by its reference local or its
+// renamed path. Typedefs come before structs, each in document order.
 function collectTypeDeclarations(
   module: ApiModule,
   skip: ReadonlySet<string>,
@@ -4409,12 +4720,15 @@ function collectTypeDeclarations(
   for (const t of module.typedefs) {
     const local =
       t.aliasOf === undefined ? (TS_IDENTIFIER.test(t.name) ? t.name : null) : localOf(t.name);
-    if (local === null || skip.has(local)) continue;
-    const name = local.slice(local.lastIndexOf(".") + 1);
+    if (local === null) continue;
+    const path = renamedLeaf(local);
+    if (skip.has(local) || skip.has(path)) continue;
+    const name = path.slice(path.lastIndexOf(".") + 1);
     const signature = typedefAlias(t, name, rawMapType, mapType);
+    if (signature === null) continue;
     out.push({
       name,
-      path: local,
+      path,
       lines: (indent, decl) => [`${indent}${decl}${signature}`],
       signature,
     });
@@ -4472,11 +4786,12 @@ function correctedListMemberType(
 
 function structDeclaration(
   struct: ApiStruct,
-  path: string,
+  local: string,
   mapType: DefoldTypeMapper,
   structs: readonly ApiStruct[],
   bindingEvidence: ReadonlySet<string>,
 ): TypeDeclaration {
+  const path = renamedLeaf(local);
   const name = path.slice(path.lastIndexOf(".") + 1);
   const memberPrefix = memberCorrectionKey(struct.name, "");
   const declared = new Set(struct.members.map((member) => member.name));
@@ -4503,7 +4818,9 @@ function structDeclaration(
   const members = [...struct.members, ...added].map((member) => {
     const key = memberCorrectionKey(struct.name, member.name);
     const list = LIST_FIELD_CORRECTIONS.get(key);
-    const retyped = TABLE_FIELD_TYPE_OVERRIDES.get(key);
+    const listedRetype = TABLE_FIELD_TYPE_OVERRIDES.get(key);
+    const retyped =
+      listedRetype?.binding === undefined || bindingEvidence.has(key) ? listedRetype : undefined;
     const optional =
       (member.isOptional || OPTIONAL_MEMBER_CORRECTIONS.has(key)) &&
       !REQUIRED_FIELD_CORRECTIONS.has(key);
@@ -4511,7 +4828,7 @@ function structDeclaration(
       list !== undefined
         ? correctedListMemberType(struct, member, list, structs, mapType)
         : retyped !== undefined
-          ? retyped
+          ? retyped.ts
           : member.type === ""
             ? "unknown"
             : mapType(member.type);
@@ -4535,7 +4852,10 @@ function structDeclaration(
         `${indent}}`,
       ];
     },
-    signature: `interface ${name} { ${members.map((member) => `${member.line} `).join("")}}`,
+    signature: interfaceSignature(
+      name,
+      members.map((member) => member.line),
+    ),
   };
 }
 
@@ -4594,8 +4914,9 @@ function moduleTypeMappers(
  * dropped, so the home's own copy wins; a type sharing a value's name
  * (`resource.atlas`) is untouched. A function moves the same way (1.13.2 files
  * `bullet3d.collision_object.get_shapes` in the shape doc), since the emitter
- * declares only the functions under a module's own namespace. Modules with
- * nothing moved in or out are returned as-is.
+ * declares only the functions under a module's own namespace. A moved type
+ * records the module that declared it as `declaredIn`. Modules with nothing
+ * moved in or out are returned as-is.
  */
 export function routeTypeDeclarations(modules: readonly ApiModule[]): ApiModule[] {
   const homeOf = (name: string, declaring: string): string => {
@@ -4625,14 +4946,14 @@ export function routeTypeDeclarations(modules: readonly ApiModule[]): ApiModule[
     const structs = (module.structs ?? []).filter((struct) => {
       const home = homeOf(struct.name, module.namespace);
       if (home === module.namespace) return true;
-      into(home).structs.push(struct);
+      into(home).structs.push({ ...struct, declaredIn: module.namespace });
       return false;
     });
     const typedefs = module.typedefs.filter((typedef) => {
       if (typedef.aliasOf === undefined) return true;
       const home = homeOf(typedef.name, module.namespace);
       if (home === module.namespace) return true;
-      into(home).typedefs.push(typedef);
+      into(home).typedefs.push({ ...typedef, declaredIn: module.namespace });
       return false;
     });
     const functions = module.functions.filter((fn) => {
@@ -4675,27 +4996,32 @@ export function routeTypeDeclarations(modules: readonly ApiModule[]): ApiModule[
 /**
  * The TS path of every `ENUM`, `STRUCT` and aliasing `TYPEDEF` the (routed)
  * modules declare, keyed by its Lua name: the name itself when it sits under its
- * module's namespace, else that name nested under the module
- * (`on_input.action` in `go` is `go.on_input.action`).
+ * module's namespace, else that name nested under the module, with its leaf
+ * through `engineTypeName` (`on_input.action` in `go` is `go.on_input.Action`).
  */
 export function declaredTypePaths(modules: readonly ApiModule[]): Map<string, string> {
   const paths = new Map<string, string>();
   for (const module of modules) {
-    const names = [
-      ...(module.enums ?? []).map((e) => e.name),
-      ...(module.structs ?? []).map((struct) => struct.name),
-      ...module.typedefs.filter((t) => t.aliasOf !== undefined).map((t) => t.name),
-    ];
-    for (const name of names) {
-      paths.set(
-        name,
-        name.startsWith(`${module.namespace}.`) ? name : `${module.namespace}.${name}`,
-      );
+    const qualified = (name: string): string =>
+      name.startsWith(`${module.namespace}.`) ? name : `${module.namespace}.${name}`;
+    for (const { name } of [
+      ...(module.enums ?? []),
+      ...(module.structs ?? []),
+      ...module.typedefs.filter((t) => t.aliasOf !== undefined),
+    ]) {
+      paths.set(name, renamedLeaf(qualified(name)));
     }
   }
   return paths;
 }
 
+// A dotted type path with its last segment through `engineTypeName`: the
+// namespace segments mirror the engine's functions and stay as they are.
+function renamedLeaf(path: string): string {
+  const dot = path.lastIndexOf(".");
+  return `${path.slice(0, dot + 1)}${engineTypeName(path.slice(dot + 1))}`;
+}
+
 export function emitDeclarations(documented: ApiModule, options?: EmitOptions): string {
   const module = withUndocumentedConstants(documented, options?.registeredConstants);
   const prefix = `${module.namespace}.`;
@@ -4744,6 +5070,13 @@ export function emitDeclarations(documented: ApiModule, options?: EmitOptions):
   const nestedRoot = collectNestedGroups(module, prefix);
   const enumAliases = collectEnumAliases(module, constants, nestedRoot);
 
+  const resolver = buildTableDocResolver(
+    module.functions.map((fn) => ({
+      name: fn.name,
+      slots: [...fn.parameters, ...fn.returnValues],
+    })),
+  );
+
   // Colon methods (`client:send`) are FUNCTION elements named `<receiver>:<method>`
   // and are NOT namespace-prefixed, so they fail the flat-identifier test in
   // prepareFunction (the colon) and are absent from `functions`. A returned handle
@@ -4751,27 +5084,26 @@ export function emitDeclarations(documented: ApiModule, options?: EmitOptions):
   // interface, the same non-flat recovery the dns nested-namespace pass does one
   // container shape shallower.
   const handleGroups = collectHandleMethodGroups(module);
-  const handleReceivers = [...handleGroups.keys()].sort((a, b) => a.localeCompare(b));
-
-  const resolver = buildTableDocResolver(
-    module.functions.map((fn) => ({
-      name: fn.name,
-      slots: [...fn.parameters, ...fn.returnValues],
-    })),
+  const handleInterfaces = collectHandleInterfaces(
+    module.namespace,
+    handleGroups,
+    mapType,
+    resolver,
+    constantTokens,
+    urlParameters,
+    bindingEvidence,
   );
 
   // A typedef that also has colon methods is emitted as a method-bearing
   // interface below, not an opaque brand alias.
-  const typeDeclarations = placeTypeDeclarations(
-    collectTypeDeclarations(
-      module,
-      new Set(handleGroups.keys()),
-      rawMapType,
-      mapType,
-      bindingEvidence,
-    ),
-    nestedRoot,
+  const collectedTypes = collectTypeDeclarations(
+    module,
+    handleTypedefNames(module.namespace, handleGroups.keys()),
+    rawMapType,
+    mapType,
+    bindingEvidence,
   );
+  const typeDeclarations = placeTypeDeclarations(collectedTypes, nestedRoot);
 
   // A re-export alias (`export { _x as x }`) switches the ambient namespace out
   // of its implicit-export mode, so once any alias is present every sibling
@@ -4788,18 +5120,24 @@ export function emitDeclarations(documented: ApiModule, options?: EmitOptions):
   lines.push(`declare namespace ${module.namespace} {`);
 
   for (const declaration of typeDeclarations) lines.push(...declaration.lines(INDENT, decl));
-  for (const aliasDecl of constantUnionAliasDeclarations(module.namespace)) {
-    lines.push(`${INDENT}${decl}${aliasDecl}`);
+  if (options?.ownsConstantUnionAliases !== false) {
+    for (const aliasDecl of constantUnionAliasDeclarations(
+      module.namespace,
+      new Set(enumAliases.all.map((alias) => alias.path)),
+    )) {
+      lines.push(`${INDENT}${decl}${aliasDecl}`);
+    }
   }
-  for (const aliasDecl of overloadSlotAliasDeclarations(
+  for (const { declaration } of overloadSlotAliasDeclarations(
     [...module.functions, ...(options?.withheldFunctions ?? [])],
+    collectedTypes,
     prefix,
     mapType,
     constantTokens,
     urlParameters,
     bindingEvidence,
   )) {
-    lines.push(`${INDENT}${decl}${aliasDecl}`);
+    lines.push(`${INDENT}${decl}${declaration}`);
   }
   for (const alias of enumAliases.topLevel) {
     lines.push(
@@ -4807,16 +5145,13 @@ export function emitDeclarations(documented: ApiModule, options?: EmitOptions):
     );
   }
   const handleIndent = `${INDENT}${INDENT}`;
-  for (const receiver of handleReceivers) {
-    const group = handleGroups.get(receiver) ?? [];
-    lines.push(`${INDENT}${decl}interface ${receiver} {`);
-    for (const fn of group) {
+  for (const { name, members } of handleInterfaces) {
+    lines.push(`${INDENT}${decl}interface ${name} {`);
+    for (const { fn, text } of members) {
       for (const docLine of functionDocLines(fn.original, translations, baseNotes, handleIndent)) {
         lines.push(docLine);
       }
-      lines.push(
-        `${handleIndent}${emitMethod(fn, mapType, resolver, constantTokens, urlParameters, bindingEvidence)}`,
-      );
+      lines.push(`${handleIndent}${text}`);
     }
     lines.push(`${INDENT}}`);
   }
@@ -4962,9 +5297,9 @@ export function emitDeclarations(documented: ApiModule, options?: EmitOptions):
 
   if (module.properties.length > 0) {
     const members = [...module.properties].sort((a, b) => a.name.localeCompare(b.name));
-    lines.push(`${INDENT}${decl}interface properties {`);
+    lines.push(`${INDENT}${decl}interface ${PROPERTIES_INTERFACE} {`);
     for (const p of members) {
-      for (const member of emitPropertyMembers(p, mapType, module.namespace)) {
+      for (const member of emitPropertyMembers(p, mapType, module.namespace, bindingEvidence)) {
         for (const docLine of summaryDocLines(p.brief, p.description, `${INDENT}${INDENT}`)) {
           lines.push(docLine);
         }
@@ -4979,17 +5314,25 @@ export function emitDeclarations(documented: ApiModule, options?: EmitOptions):
 }
 
 // One `type <alias> = <slot type>;` per `OVERLOAD_SLOT_ALIASES` slot these
-// functions carry, in alias order. The type is the one `emitFunction` reports
-// for the slot, so it reads as the function's own signature would. The
-// resolver spans these functions alone, leaving the module's own untouched.
+// functions carry, in alias order, skipping an alias one of the module's
+// top-level type `declarations` already names. The type is the one
+// `emitFunction` reports for the slot, so it reads as the function's own
+// signature would. The resolver spans these functions alone, leaving the
+// module's own untouched.
 function overloadSlotAliasDeclarations(
   functions: readonly ApiFunction[],
+  declarations: readonly TypeDeclaration[],
   prefix: string,
   mapType: DefoldTypeMapper,
   constantTokens: ConstantSlotTokens,
   urlParameters: UrlParameterTable,
   bindingEvidence: ReadonlySet<string>,
-): string[] {
+): { name: string; declaration: string }[] {
+  const declared = new Set(
+    declarations
+      .filter((declaration) => declaration.path === declaration.name)
+      .map((declaration) => declaration.name),
+  );
   const resolver = buildTableDocResolver(
     functions.map((fn) => ({ name: fn.name, slots: [...fn.parameters, ...fn.returnValues] })),
   );
@@ -4997,7 +5340,7 @@ function overloadSlotAliasDeclarations(
   for (const fn of functions) {
     for (const [position, p] of fn.parameters.entries()) {
       const alias = OVERLOAD_SLOT_ALIASES.get(tableSlotKey(fn.name, "param", p.name));
-      if (alias === undefined) continue;
+      if (alias === undefined || declared.has(alias)) continue;
       const prepared = prepareFunction(fn, prefix);
       if (prepared === null) continue;
       const slots: Record<string, SlotType> = {};
@@ -5024,7 +5367,51 @@ function overloadSlotAliasDeclarations(
   }
   return [...types]
     .sort(([a], [b]) => a.localeCompare(b))
-    .map(([alias, type]) => `type ${alias} = ${type};`);
+    .map(([name, type]) => ({ name, declaration: `type ${name} = ${type};` }));
+}
+
+// A method of a handle interface: the member text the declarations print inside
+// the interface, which its FUNCTION entry signs too.
+interface HandleMember {
+  fn: PreparedFunction;
+  text: string;
+  slotTypes: SlotTypes;
+}
+
+// Each handle interface a module's colon methods declare, sorted by name, with
+// its methods in group order.
+function collectHandleInterfaces(
+  namespace: string,
+  handleGroups: ReadonlyMap<string, readonly PreparedFunction[]>,
+  mapType: DefoldTypeMapper,
+  resolver: TableDocResolver,
+  constantTokens: ConstantSlotTokens,
+  urlParameters: UrlParameterTable,
+  bindingEvidence: ReadonlySet<string>,
+): { name: string; members: HandleMember[] }[] {
+  return [...handleGroups]
+    .map(([receiver, group]) => ({
+      name: handleInterfaceName(namespace, receiver),
+      members: group.map((fn): HandleMember => {
+        const slotTypes: Record<string, SlotType> = {};
+        const text = emitMethod(
+          fn,
+          mapType,
+          resolver,
+          constantTokens,
+          urlParameters,
+          bindingEvidence,
+          slotTypes,
+        );
+        return { fn, text, slotTypes };
+      }),
+    }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// An interface signed on one line, each member line followed by a space.
+function interfaceSignature(name: string, members: readonly string[]): string {
+  return `interface ${name} { ${members.map((member) => `${member} `).join("")}}`;
 }
 
 /**
@@ -5184,24 +5571,29 @@ export function emitSymbolSignatures(
     });
   }
 
+  // A handle interface signs as one line, as a struct does; each member is the
+  // text its method's FUNCTION entry signs.
   const handleGroups = collectHandleMethodGroups(module);
-  for (const group of handleGroups.values()) {
-    for (const prepared of group) {
-      const slotTypes: Record<string, SlotType> = {};
-      out.push({
-        identity: fnIdentity(prepared.original),
-        tsSignature: emitMethod(
-          prepared,
-          mapType,
-          resolver,
-          constantTokens,
-          urlParameters,
-          bindingEvidence,
-          slotTypes,
-        ),
-        slotTypes,
-      });
+  for (const { name, members } of collectHandleInterfaces(
+    module.namespace,
+    handleGroups,
+    mapType,
+    resolver,
+    constantTokens,
+    urlParameters,
+    bindingEvidence,
+  )) {
+    for (const { fn, text, slotTypes } of members) {
+      out.push({ identity: fnIdentity(fn.original), tsSignature: text, slotTypes });
     }
+    out.push({
+      identity: { namespace: module.namespace, kind: "TYPEDEF", name, signature: "" },
+      tsSignature: interfaceSignature(
+        name,
+        members.map((member) => member.text),
+      ),
+      slotTypes: NO_SLOTS,
+    });
   }
 
   const constants: PreparedConstant[] = [];
@@ -5230,7 +5622,7 @@ export function emitSymbolSignatures(
   // carries the first, which is verbatim in the `.d.ts` and is what the `/api`
   // render layer reduces to `<placeholder>: <type>`.
   for (const p of module.properties) {
-    const [firstMember = ""] = emitPropertyMembers(p, mapType, module.namespace);
+    const [firstMember = ""] = emitPropertyMembers(p, mapType, module.namespace, bindingEvidence);
     out.push({
       identity: { namespace: module.namespace, kind: "PROPERTY", name: p.name, signature: "" },
       tsSignature: firstMember,
@@ -5240,13 +5632,14 @@ export function emitSymbolSignatures(
 
   // A struct signs as its interface on one line; each member line is verbatim in
   // the declarations.
-  for (const declaration of collectTypeDeclarations(
+  const typeDeclarations = collectTypeDeclarations(
     module,
-    new Set(handleGroups.keys()),
+    handleTypedefNames(module.namespace, handleGroups.keys()),
     rawMapType,
     mapType,
     bindingEvidence,
-  )) {
+  );
+  for (const declaration of typeDeclarations) {
     out.push({
       identity: {
         namespace: module.namespace,
@@ -5259,23 +5652,54 @@ export function emitSymbolSignatures(
     });
   }
 
+  // An overload-slot alias is declared exactly where the declarations carry it,
+  // so it signs from the same functions and the same declared set.
+  for (const { name, declaration } of overloadSlotAliasDeclarations(
+    [...module.functions, ...(options?.withheldFunctions ?? [])],
+    typeDeclarations,
+    prefix,
+    mapType,
+    constantTokens,
+    urlParameters,
+    bindingEvidence,
+  )) {
+    out.push({
+      identity: { namespace: module.namespace, kind: "TYPEDEF", name, signature: "" },
+      tsSignature: declaration,
+      slotTypes: NO_SLOTS,
+    });
+  }
+
   // The module's constant-union aliases travel as typedefs too: a signature that
   // names one carries no member list of its own, so the docs read the members
   // from here rather than from the emitter's table.
-  for (const row of CONSTANT_UNION_ALIASES.filter((r) => r.home === module.namespace)) {
+  const enumAliases = collectEnumAliases(module, constants, nestedRoot);
+  const ownedAliases =
+    options?.ownsConstantUnionAliases === false
+      ? []
+      : ownedConstantUnionAliases(
+          module.namespace,
+          new Set(enumAliases.all.map((alias) => alias.path)),
+        );
+  for (const row of ownedAliases) {
+    const name = engineTypeName(row.name);
     out.push({
-      identity: { namespace: module.namespace, kind: "TYPEDEF", name: row.name, signature: "" },
-      tsSignature: unionAliasDeclaration(row.name, row.members),
+      identity: { namespace: module.namespace, kind: "TYPEDEF", name, signature: "" },
+      tsSignature: unionAliasDeclaration(name, row.members),
       slotTypes: NO_SLOTS,
     });
   }
 
-  // An enum alias is keyed by its local path (`STATUS`, `ui.COLOR`), as the
-  // constant-union aliases above are keyed by their local name.
-  const enumAliases = collectEnumAliases(module, constants, nestedRoot);
+  // An enum alias is keyed by its declared local path (`Status`, `ui.Color`),
+  // as the constant-union aliases above are keyed by their declared name.
   for (const alias of enumAliases.all) {
     out.push({
-      identity: { namespace: module.namespace, kind: "TYPEDEF", name: alias.path, signature: "" },
+      identity: {
+        namespace: module.namespace,
+        kind: "TYPEDEF",
+        name: renamedLeaf(alias.path),
+        signature: "",
+      },
       tsSignature: unionAliasDeclaration(alias.name, alias.members, alias.nilable),
       slotTypes: NO_SLOTS,
     });
@@ -5317,8 +5741,9 @@ interface NestedGroup {
   children: Map<string, NestedGroup>;
 }
 
-// One `ENUM`'s union alias: `name` is the declared identifier, `path` the local
-// path under the module namespace (`ui.COLOR`), `members` the member FQNs.
+// One `ENUM`'s union alias: `name` is the declared identifier (`Color`), `path`
+// the reference's local path under the module namespace (`ui.COLOR`), `members`
+// the member FQNs.
 interface EnumAlias {
   name: string;
   path: string;
@@ -5447,12 +5872,14 @@ function collectEnumAliases(
   const nilable = new Set(module.constants.filter((c) => c.nilable).map((c) => c.name));
   const topLevel: EnumAlias[] = [];
   const all: EnumAlias[] = [];
-  const enums = [...(module.enums ?? [])].sort((a, b) => a.name.localeCompare(b.name));
+  const enums = [...(module.enums ?? [])].sort((a, b) =>
+    renamedLeaf(a.name).localeCompare(renamedLeaf(b.name)),
+  );
   for (const e of enums) {
     if (e.members.length === 0 || !e.members.every((m) => declared.has(m))) continue;
     const path = stripPrefix(e.name, prefix);
     if (TS_IDENTIFIER.test(path)) {
-      const alias = { name: path, path, members: e.members, nilable };
+      const alias = { name: engineTypeName(path), path, members: e.members, nilable };
       topLevel.push(alias);
       all.push(alias);
       continue;
@@ -5468,7 +5895,7 @@ function collectEnumAliases(
       level = group.children;
     }
     if (group === undefined) continue;
-    const alias = { name, path, members: e.members, nilable };
+    const alias = { name: engineTypeName(name), path, members: e.members, nilable };
     group.enumAliases.push(alias);
     all.push(alias);
   }
@@ -5749,6 +6176,7 @@ function memberSignature(
       constantTokens,
       elementName,
       urlParameters,
+      bindingEvidence,
       required.has(i),
       prepared.retype?.get(i),
     ),
@@ -5764,6 +6192,7 @@ function memberSignature(
           constantTokens,
           elementName,
           urlParameters,
+          bindingEvidence,
         );
   const params = [...positional.map((p) => p.text), ...(rest ? [rest.text] : [])].join(", ");
   const ret = emitReturn(
@@ -6029,6 +6458,7 @@ function parameterType(
   constantTokens: ConstantSlotTokens,
   elementName: string,
   urlParameters: UrlParameterTable,
+  bindingEvidence: ReadonlySet<string>,
 ): string {
   const concrete = p.types.filter((t) => t !== "nil");
   // The caller supplies a parameter, so a string-keyed table in it also takes an
@@ -6050,10 +6480,20 @@ function parameterType(
           elementName,
           "param",
           p.name,
+          bindingEvidence,
+          p.fields,
         )
       : "unknown";
-  const correction = PARAM_TYPE_CORRECTIONS.get(tableSlotKey(elementName, "param", p.name));
-  if (correction === undefined || !pinMatches(p.types, correctionPins(correction))) return mapped;
+  const key = tableSlotKey(elementName, "param", p.name);
+  const correction = PARAM_TYPE_CORRECTIONS.get(key);
+  if (
+    correction === undefined ||
+    !pinMatches(p.types, correctionPins(correction)) ||
+    (correction.binding !== undefined && !bindingEvidence.has(key))
+  ) {
+    return mapped;
+  }
+  if (correction.ts !== undefined) return correction.ts;
   const kept =
     correction.removes === undefined ? mapped : withoutUnionMembers(mapped, correction.removes);
   if (correction.adds === undefined) return kept;
@@ -6135,13 +6575,22 @@ function emitRestParameter(
   constantTokens: ConstantSlotTokens,
   elementName: string,
   urlParameters: UrlParameterTable,
+  bindingEvidence: ReadonlySet<string>,
 ): { text: string; slots: EmittedSlot[] } {
   const vararg = params[varargIndex];
   if (vararg === undefined) return { text: "", slots: [] };
   const folded = params.slice(varargIndex).map((p, offset) => ({
     position: varargIndex + offset,
     name: p.name,
-    ts: parameterType(p, mapType, resolver, constantTokens, elementName, urlParameters),
+    ts: parameterType(
+      p,
+      mapType,
+      resolver,
+      constantTokens,
+      elementName,
+      urlParameters,
+      bindingEvidence,
+    ),
   }));
   const members = [...new Set(folded.map((slot) => slot.ts))];
   const first = members[0] ?? "unknown";
@@ -6169,12 +6618,21 @@ function emitParameter(
   constantTokens: ConstantSlotTokens,
   elementName: string,
   urlParameters: UrlParameterTable,
+  bindingEvidence: ReadonlySet<string>,
   required = false,
   retype: (type: string) => string = (type) => type,
 ): { text: string; type: string; optional: boolean } {
   const name = safeParamName(p.name, index);
   const ts = retype(
-    parameterType(p, mapType, resolver, constantTokens, elementName, urlParameters),
+    parameterType(
+      p,
+      mapType,
+      resolver,
+      constantTokens,
+      elementName,
+      urlParameters,
+      bindingEvidence,
+    ),
   );
   // An interior doc-optional param (a required param follows, so the trailing-`?`
   // projection cannot mark it) keeps its optionality as `| undefined` — TSTL
@@ -6246,6 +6704,8 @@ function emitReturn(
                 elementName,
                 "return",
                 rv.name,
+                bindingEvidence,
+                rv.fields,
               )
             : "unknown"),
       };
@@ -6284,6 +6744,8 @@ function emitReturn(
           elementName,
           "return",
           first.name,
+          bindingEvidence,
+          first.fields,
         )
       : "unknown";
   // A LuaLS vararg return (`...`) is every value the call returns, however many.
@@ -6323,12 +6785,17 @@ function emitPropertyMembers(
   p: ApiProperty,
   mapType: DefoldTypeMapper,
   namespace: string,
+  bindingEvidence: ReadonlySet<string>,
 ): readonly string[] {
-  const keyRange = PROPERTY_KEY_RANGES.get(`${namespace}.${p.name}`);
+  const rangeKey = `${namespace}.${p.name}`;
+  const keyRange = PROPERTY_KEY_RANGES.get(rangeKey);
   const keys: string[] = [];
   if (keyRange !== undefined) {
-    for (let unit = keyRange.first; unit <= keyRange.last; unit++)
-      keys.push(`${keyRange.prefix}${unit}`);
+    const last =
+      keyRange.engine !== undefined && bindingEvidence.has(rangeKey)
+        ? keyRange.engine.last
+        : keyRange.last;
+    for (let unit = keyRange.first; unit <= last; unit++) keys.push(`${keyRange.prefix}${unit}`);
   } else {
     keys.push(TS_IDENTIFIER.test(p.name) ? p.name : JSON.stringify(p.name));
   }
@@ -6392,6 +6859,73 @@ function wrappedInParens(text: string): boolean {
   return false;
 }
 
+// A ref-doc slot's structured `fields` (a `.script_api` callback's `parameters:`
+// or a table's `fields:`) as the field list `inlineTableType` renders. A field
+// flagged `is_optional` keeps that flag so a return-side or callback-argument
+// table marks only it `?`; a nested table's own fields nest the same way.
+function refDocTableFields(fields: readonly ApiParameter[]): TableField[] {
+  return fields.map((field) => {
+    const out: TableField = { name: field.name, types: field.types };
+    if (field.fields !== undefined) out.fields = refDocTableFields(field.fields);
+    if (field.isOptional) out.optional = true;
+    return out;
+  });
+}
+
+// The TS type of one documented callback argument. The engine supplies these
+// values, so a table argument's fields are required unless flagged optional; a
+// `self` argument is the calling script instance, typed `unknown` like the
+// engine callback corrections type it.
+// A `constant` argument expands to the brands its own doc names, through the
+// slot's constant resolver; one whose doc names none keeps the generic brand.
+function callbackArgumentType(
+  field: ApiParameter,
+  mapType: DefoldTypeMapper,
+  constantsNamed: (doc: string) => readonly string[],
+): string {
+  if (field.name === "self") return "unknown";
+  if (field.fields !== undefined && field.fields.length > 0) {
+    if (field.types.includes("function")) {
+      return callbackTypeFromFields(field.fields, mapType, constantsNamed);
+    }
+    if (field.types.includes("table")) {
+      return inlineTableType(refDocTableFields(field.fields), mapType, false);
+    }
+  }
+  if (field.types.includes("constant")) {
+    const fqns = constantsNamed(field.doc);
+    if (fqns.length > 0) {
+      const others = field.types.filter((token) => token !== "constant");
+      return unionFromTokens([...fqns, ...others], mapType);
+    }
+  }
+  return field.types.length > 0 ? unionFromTokens(field.types, mapType) : "unknown";
+}
+
+// Renders a `function` slot's documented arguments as `(name: T, ...) => void`.
+// Optionality follows `emitParameter`: a trailing optional run takes `?`, an
+// interior optional argument takes `| undefined` because TS forbids a required
+// parameter after an optional one.
+function callbackTypeFromFields(
+  fields: readonly ApiParameter[],
+  mapType: DefoldTypeMapper,
+  constantsNamed: (doc: string) => readonly string[],
+): string {
+  let trailingOptionalFrom = fields.length;
+  while (trailingOptionalFrom > 0 && fields[trailingOptionalFrom - 1]?.isOptional === true) {
+    trailingOptionalFrom--;
+  }
+  const args = fields.map((field, index) => {
+    const name = safeParamName(field.name, index);
+    const ts = callbackArgumentType(field, mapType, constantsNamed);
+    if (index >= trailingOptionalFrom) return `${name}?: ${ts}`;
+    if (!field.isOptional) return `${name}: ${ts}`;
+    const operand = isFunctionTypeText(ts) ? `(${ts})` : ts;
+    return `${name}: ${operand} | undefined`;
+  });
+  return `(${args.join(", ")}) => void`;
+}
+
 // Like `unionFromTokens`, but a `table` token whose slot doc carries a parseable
 // `<dl>` field list emits an inline object type instead of the opaque `Record`
 // fallback. Other tokens in the union map unchanged. `optionalFields` marks the
@@ -6399,6 +6933,10 @@ function wrappedInParens(text: string): boolean {
 // optionality and an input option-bag's fields are individually omittable (the
 // old `Record` accepted partial/empty objects), so a parameter's fields are
 // optional while a return's fields (engine-populated, all present) stay required.
+// A slot carrying structured ref-doc `fields` (a `.script_api` conversion) types
+// a `table` token from them ahead of the prose parser and the curations, the
+// precedence `slotFieldNames` applies, and a `function` token from them as a
+// typed callback signature.
 function mapSlotUnion(
   types: readonly string[],
   doc: string,
@@ -6407,8 +6945,10 @@ function mapSlotUnion(
   resolver: TableDocResolver,
   constantTokens: ConstantSlotTokens,
   elementName: string,
-  slotKind?: "param" | "return",
-  slotName?: string,
+  slotKind: "param" | "return" | undefined,
+  slotName: string | undefined,
+  bindingEvidence: ReadonlySet<string>,
+  fields?: readonly ApiParameter[],
 ): string {
   const mapped: string[] = [];
   const seen = new Set<string>();
@@ -6417,6 +6957,7 @@ function mapSlotUnion(
     seen.add(ts);
     mapped.push(ts);
   };
+  const structured = fields !== undefined && fields.length > 0 ? fields : undefined;
   for (const token of types) {
     if (token === "constant" && slotKind !== undefined && slotName !== undefined) {
       const expanded = constantTokens(elementName, slotKind, slotName, doc);
@@ -6430,7 +6971,15 @@ function mapSlotUnion(
       slotKind !== undefined && slotName !== undefined
         ? TABLE_SLOT_CURATIONS.get(tableSlotKey(elementName, slotKind, slotName))
         : undefined;
-    if (token === "table" || slotCuration?.retypedUpstream?.includes(token) === true) {
+    if (token === "table" && structured !== undefined) {
+      ts = inlineTableType(refDocTableFields(structured), mapType, optionalFields);
+    } else if (token === "function" && structured !== undefined) {
+      ts = callbackTypeFromFields(structured, mapType, (fieldDoc) =>
+        slotKind !== undefined && slotName !== undefined
+          ? constantTokens(elementName, slotKind, slotName, fieldDoc)
+          : [],
+      );
+    } else if (token === "table" || slotCuration?.retypedUpstream?.includes(token) === true) {
       const curation = slotCuration;
       const mapping =
         curation?.kind === "mapping" ? curation : MAPPING_TABLE_SLOTS.get(elementName);
@@ -6501,6 +7050,7 @@ function mapSlotUnion(
             slotKind,
             slotName,
             parseTableFields(doc, resolver, slotName) ?? [],
+            bindingEvidence,
           ),
         );
         const object = inlineTableType(parsed, mapType, optionalFields);
@@ -6510,7 +7060,13 @@ function mapSlotUnion(
         if (parsed !== null) {
           const added = applyFieldAdditions(elementName, slotKind, slotName, parsed);
           const nested = applyNestedFieldCurations(elementName, slotKind, slotName, added);
-          const typed = applyFieldTypeOverrides(elementName, slotKind, slotName, nested);
+          const typed = applyFieldTypeOverrides(
+            elementName,
+            slotKind,
+            slotName,
+            nested,
+            bindingEvidence,
+          );
           const required = applyRequiredFieldCorrections(
             elementName,
             slotKind,
@@ -6680,8 +7236,8 @@ function withoutSubsumedOpaqueArms(mapped: readonly string[]): string[] {
   });
 }
 
-// Joins already-mapped arms, collapsing the branded ones to their alias when
-// they are exactly a `CONSTANT_UNION_ALIASES` member set. The alias takes the
+// Joins already-mapped arms, collapsing the branded ones to their row's spelling
+// when they are exactly a `CONSTANT_UNION_ALIASES` member set. The spelling takes the
 // position of the first branded arm, so a mixed union keeps its reading order
 // (`gui.Easing | Vector`). Arms that are not constants are untouched, and a set
 // with no row keeps every arm inline.
@@ -6699,7 +7255,7 @@ function joinUnionArms(mapped: readonly string[]): string {
   for (const arm of arms) {
     if (BRAND_ARM.test(arm)) {
       if (placed) continue;
-      out.push(`${alias.home}.${alias.name}`);
+      out.push(constantUnionSpelling(alias));
       placed = true;
       continue;
     }