@defold-typescript/types 0.52.0 → 0.54.0

package/src/engine-type-name.ts

@@ -0,0 +1,33 @@
+// Reference names the rule cannot split into words: the reference writes these
+// as one run of capitals, or runs a number into a word (Bullet spells the joint
+// `btGeneric6DofConstraint`).
+export const ENGINE_TYPE_NAME_OVERRIDES: ReadonlyMap<string, string> = new Map([
+  ["LIVEUPDATE", "LiveUpdate"],
+  ["PIEBOUNDS", "PieBounds"],
+  ["SYSFIELD", "SysField"],
+  ["USERFIELD", "UserField"],
+  ["generic_6dof_params", "Generic6DofParams"],
+  ["generic_6dof_spring_params", "Generic6DofSpringParams"],
+]);
+
+/**
+ * The PascalCase TypeScript name of a reference type leaf (`EASING` ->
+ * `Easing`, `sys_info` -> `SysInfo`, `b2Body` -> `B2Body`). A word written in
+ * one case is capitalized; a mixed-case word keeps its inner capitals.
+ */
+export function engineTypeName(
+  referenceLeaf: string,
+  overrides: ReadonlyMap<string, string> = ENGINE_TYPE_NAME_OVERRIDES,
+): string {
+  const override = overrides.get(referenceLeaf);
+  if (override !== undefined) return override;
+  return referenceLeaf
+    .split("_")
+    .filter((part) => part.length > 0)
+    .map((part) =>
+      part === part.toUpperCase() || part === part.toLowerCase()
+        ? part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()
+        : part.charAt(0).toUpperCase() + part.slice(1),
+    )
+    .join("");
+}

package/src/go-overloads.d.ts

@@ -51,7 +51,7 @@ declare global {
      * const position = go.get("#sprite", "position");
      * // Name the target component to read its catalogued property type. The
      * // empty call applies the type argument, then the inner call infers the key:
-     * const animation = go.get<sprite.properties>()("#sprite", "animation"); // Hash
+     * const animation = go.get<sprite.Properties>()("#sprite", "animation"); // Hash
      * ```
      */
     function get<P>(): <K extends keyof P>(
@@ -59,15 +59,15 @@ declare global {
       property: K,
       ...options: [] | [GoPropertyOptions]
     ) => P[K];
-    function get<K extends keyof go.properties>(
+    function get<K extends keyof go.Properties>(
       url: SceneAddress | Hash | Url,
       property: K,
-    ): go.properties[K];
-    function get<K extends keyof go.properties>(
+    ): go.Properties[K];
+    function get<K extends keyof go.Properties>(
       url: SceneAddress | Hash | Url,
       property: K,
       options: GoPropertyOptions,
-    ): go.properties[K];
+    ): go.Properties[K];
     function get(
       url: SceneAddress | Hash | Url,
       property: string | Hash,
@@ -114,7 +114,7 @@ declare global {
      * // Name the target component to gate the value to its property type. The
      * // empty call applies the type argument, then the inner call infers the key.
      * // A read-only property such as "animation" is not a key it accepts:
-     * go.set<sprite.properties>()("#sprite", "playback_rate", 2);
+     * go.set<sprite.Properties>()("#sprite", "playback_rate", 2);
      * ```
      */
     function set<P>(): <K extends WritableKey<P>>(
@@ -123,15 +123,15 @@ declare global {
       value: P[K],
       ...options: [] | [GoPropertyOptions]
     ) => void;
-    function set<K extends keyof go.properties>(
+    function set<K extends keyof go.Properties>(
       url: SceneAddress | Hash | Url,
       property: K,
-      value: go.properties[K],
+      value: go.Properties[K],
     ): void;
-    function set<K extends keyof go.properties>(
+    function set<K extends keyof go.Properties>(
       url: SceneAddress | Hash | Url,
       property: K,
-      value: go.properties[K],
+      value: go.Properties[K],
       options: GoPropertyOptions,
     ): void;
     function set(

package/src/gui-overloads.d.ts

@@ -17,17 +17,17 @@ type PropName<P> = P extends { readonly __brand: `gui.PROP_${infer S}` } ? Lower
 // gui.cpp g_Properties: these four have no `.x`..`.w` sub-keys.
 type ScalarName = "inner_radius" | "fill_angle" | "leading" | "tracking";
 
-type VectorName = Exclude<PropName<gui.Property>, ScalarName>;
+type VectorName = Exclude<PropName<gui.Prop>, ScalarName>;
 
-type NodePropertyName<K> = K extends keyof gui.node_properties
+type NodePropertyName<K> = K extends keyof gui.NodeProperties
   ? K
-  : Extract<PropName<K>, keyof gui.node_properties>;
+  : Extract<PropName<K>, keyof gui.NodeProperties>;
 
 // gui_script.cpp:LuaSet: `rotation` takes only a quat, every other vector a
 // vector4 or a vector3, and a sub-key or scalar a number.
-type NodePropertyWrite<N extends keyof gui.node_properties> = N extends "rotation"
+type NodePropertyWrite<N extends keyof gui.NodeProperties> = N extends "rotation"
   ? Quaternion
-  : gui.node_properties[N] extends number
+  : gui.NodeProperties[N] extends number
     ? number
     : Vector4 | Vector3;
 
@@ -38,7 +38,7 @@ declare global {
      * property reads as a vmath.vector4 and `rotation` as a vmath.quat; their
      * `.x`..`.w` sub-keys and the four scalar properties read as a number.
      */
-    type node_properties = {
+    type NodeProperties = {
       [K in
         | VectorName
         | `${VectorName}.${"x" | "y" | "z" | "w"}`
@@ -87,10 +87,10 @@ declare global {
      * const node_position = gui.get(node, "position");
      * ```
      */
-    function get<K extends keyof gui.node_properties | gui.Property>(
+    function get<K extends keyof gui.NodeProperties | gui.Prop>(
       node: Opaque<"node">,
       property: K,
-    ): gui.node_properties[NodePropertyName<K>];
+    ): gui.NodeProperties[NodePropertyName<K>];
     /**
      * Gets a material constant of a node, or any property named by a hash. Pass
      * the constant's name as a hash, such as `hash("tint")`. Reading an array
@@ -173,7 +173,7 @@ declare global {
      * gui.set_rotation(node, vmath.vector3(0, 0, 45));
      * ```
      */
-    function set<K extends keyof gui.node_properties | gui.Property>(
+    function set<K extends keyof gui.NodeProperties | gui.Prop>(
       node: Opaque<"node">,
       property: K,
       value: NodePropertyWrite<NodePropertyName<K>>,
@@ -393,7 +393,7 @@ declare global {
      */
     function animate(
       node: Opaque<"node">,
-      property: keyof gui.node_properties | gui.Property | Hash,
+      property: keyof gui.NodeProperties | gui.Prop | Hash,
       to: number | Vector3 | Vector4 | Quaternion,
       easing: gui.Easing | Vector,
       duration: number,
@@ -477,7 +477,7 @@ declare global {
      */
     function animate(
       node: Opaque<"node">,
-      property: keyof gui.node_properties | gui.Property | Hash,
+      property: keyof gui.NodeProperties | gui.Prop | Hash,
       to: number | Vector3 | Vector4 | Quaternion,
       easing: gui.Easing | Vector,
       duration: number,

package/src/index-slot-classifications.ts

@@ -1,5 +1,4 @@
 import { htmlToDocText } from "./doc-comment";
-import { LIBRARY_INDEX_SLOT_CLASSIFICATIONS } from "./library-index-slot-classifications";
 
 // The class records the base Defold itself counts from. TypeScript passes every
 // engine position to Defold, and takes it back, unchanged in that base:
@@ -543,36 +542,101 @@ export function withIndexBaseNotes(
   return appendNotes(doc, indexBaseNotes(elementName, kind, slotName));
 }
 
+// The class records the base the library itself counts from, which TypeScript
+// passes through unchanged, exactly as `INDEX_SLOT_CLASSIFICATIONS` records
+// Defold's.
+export type LibraryIndexSlotClassifications = ReadonlyMap<
+  string,
+  Pick<IndexSlotClassification, "class" | "evidence">
+>;
+
+const INDEX_SLOT_CLASSES: ReadonlySet<string> = new Set<IndexSlotClass>([
+  "native-1",
+  "native-0",
+  "not-a-position",
+]);
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// Keyed `<page>/<element>:<param|return|field>:<slot>[:<field>]`, `<page>` being
+// the library page key (`gooey`, `spine.gui`, `rive.cmd`), so a library slot
+// never shares a key with an engine one (`spine.gui` documents `gui.*`). A class
+// field is keyed `<page>/<Typedef>:field:<member>`, a callback argument as a
+// field of its callback slot, and each positional value of an unnamed
+// multi-value return as a field of that return (`cast:return::tile_x`). A
+// typedef method is keyed by its bare name, so one key covers every class of the
+// page that declares that method.
+// `docs-site/app/lib/library-index-slot-gate.test.ts` reds on a scanned slot
+// missing from `library-types/index-slot-classifications.json` and on an entry
+// no library page declares.
+export function parseLibraryIndexSlotClassifications(
+  json: unknown,
+): LibraryIndexSlotClassifications {
+  if (!isPlainObject(json)) {
+    throw new Error("library index-slot classifications must be a JSON object");
+  }
+  const map = new Map<string, Pick<IndexSlotClassification, "class" | "evidence">>();
+  for (const [key, value] of Object.entries(json)) {
+    if (!isPlainObject(value)) {
+      throw new Error(`library index-slot classification ${key} must be an object`);
+    }
+    const { class: slotClass, evidence } = value;
+    if (typeof slotClass !== "string" || !INDEX_SLOT_CLASSES.has(slotClass)) {
+      throw new Error(
+        `library index-slot classification ${key} has class ${JSON.stringify(slotClass)}, not one of ${[...INDEX_SLOT_CLASSES].join(", ")}`,
+      );
+    }
+    if (typeof evidence !== "string" || evidence.trim() === "") {
+      throw new Error(`library index-slot classification ${key} needs a non-blank evidence string`);
+    }
+    map.set(key, { class: slotClass as IndexSlotClass, evidence });
+  }
+  return map;
+}
+
 // The same notes for a slot or class field of a library page, read from the
 // library map under that page's key and naming the library as the receiver.
 export function libraryIndexBaseNotes(
+  classifications: LibraryIndexSlotClassifications,
   page: string,
   elementName: string,
   kind: "param" | "return" | "field",
   slotName: string,
 ): string[] {
   return slotBaseNotes(
-    LIBRARY_INDEX_SLOT_CLASSIFICATIONS,
+    classifications,
     `\`${page}\``,
     `${page}/${elementName}:${kind}:${slotName}`,
   );
 }
 
 export function withLibraryIndexBaseNotes(
+  classifications: LibraryIndexSlotClassifications,
   page: string,
   elementName: string,
   kind: "param" | "return" | "field",
   slotName: string,
   doc: string,
 ): string {
-  return appendNotes(doc, libraryIndexBaseNotes(page, elementName, kind, slotName));
+  return appendNotes(
+    doc,
+    libraryIndexBaseNotes(classifications, page, elementName, kind, slotName),
+  );
 }
 
 // Where a declaration's index notes come from: the engine map, naming Defold, or
-// the library map under each listed page, naming that library. A library or
-// extension declaration never reads the engine map, so an element it shares a
-// name with (`spine.gui` declares `gui.*`) never claims Defold as its receiver.
-export type IndexBaseSource = "engine" | { readonly pages: readonly string[] };
+// the caller's library map under each listed page, naming that library. A
+// library or extension declaration never reads the engine map, so an element it
+// shares a name with (`spine.gui` declares `gui.*`) never claims Defold as its
+// receiver.
+export type IndexBaseSource =
+  | "engine"
+  | {
+      readonly pages: readonly string[];
+      readonly classifications: LibraryIndexSlotClassifications;
+    };
 
 export type IndexBaseNoteResolver = (
   elementName: string,
@@ -582,7 +646,9 @@ export type IndexBaseNoteResolver = (
 
 export function indexBaseNoteResolver(source: IndexBaseSource): IndexBaseNoteResolver {
   if (source === "engine") return indexBaseNotes;
-  const { pages } = source;
+  const { pages, classifications } = source;
   return (elementName, kind, slotName) =>
-    pages.flatMap((page) => libraryIndexBaseNotes(page, elementName, kind, slotName));
+    pages.flatMap((page) =>
+      libraryIndexBaseNotes(classifications, page, elementName, kind, slotName),
+    );
 }

package/src/index.ts

@@ -67,6 +67,7 @@ export {
   TS_IDENTIFIER,
   TS_RESERVED_NAMES,
 } from "./emit-dts";
+export { ENGINE_TYPE_NAME_OVERRIDES, engineTypeName } from "./engine-type-name";
 export {
   hashExampleSource,
   lookupExampleSegments,
@@ -87,11 +88,12 @@ export {
   INDEX_SLOT_CLASSIFICATIONS,
   type IndexSlotClass,
   type IndexSlotClassification,
+  type LibraryIndexSlotClassifications,
   libraryIndexBaseNotes,
+  parseLibraryIndexSlotClassifications,
   withIndexBaseNotes,
   withLibraryIndexBaseNotes,
 } from "./index-slot-classifications";
-export { LIBRARY_INDEX_SLOT_CLASSIFICATIONS } from "./library-index-slot-classifications";
 export {
   hasTopLevelUnion,
   luaMultiReturn,
@@ -130,6 +132,7 @@ export {
   type ModuleWrapOptions,
   type WrapOptions,
   wrapAsAmbientGlobal,
+  wrapAsGlobalTableModule,
   wrapAsModule,
 } from "./publish-dts";
 export {

package/src/lifecycle.ts

@@ -1,6 +1,6 @@
 import type { Hash, Url } from "./core-types";
 
-// Fields and docs follow the go ref-doc's `on_input.touch` STRUCT, whose keys are
+// Fields and docs follow the go ref-doc's `on_input.touch` STRUCT (`go.on_input.Touch`), whose keys are
 // the ones comp_script.cpp pushes; lifecycle-member-docs drift-guards the docs
 // against it, and a ref-doc re-pin is reconciled by hand.
 export interface InputTouch {
@@ -54,7 +54,7 @@ export interface InputTouch {
   screen_dy: number;
 }
 
-// Fields and docs follow the go ref-doc's `on_input.action` STRUCT, whose keys are
+// Fields and docs follow the go ref-doc's `on_input.action` STRUCT (`go.on_input.Action`), whose keys are
 // the ones comp_script.cpp pushes; lifecycle-member-docs drift-guards the docs
 // against it, and a ref-doc re-pin is reconciled by hand.
 export interface InputAction {

package/src/publish-dts.ts

@@ -45,6 +45,22 @@ export function wrapAsAmbientGlobal(opts: WrapOptions): string {
   return `/** @noSelfInFile */\n${importLine}declare global {\n${indented}\n}\n\nexport {};\n`;
 }
 
+// The emitted namespace as an ambient `declare module "<namespace>"` tagged
+// `@globalTable`, so an import lowers to a local alias of the global the
+// extension registers. The description stays a separate JSDoc above the tag,
+// since TypeScript reads tags from the last one. The body keeps the namespace's
+// indentation, and engine handles resolve as ambient globals, as in
+// `wrapAsModule`.
+export function wrapAsGlobalTableModule(opts: WrapOptions): string {
+  const body = opts.emitted
+    .replace(
+      /(^|\n)declare\s+namespace\s+[\w$.]+\s*\{/,
+      (_match, lead) => `${lead}/** @globalTable */\ndeclare module "${opts.namespace}" {`,
+    )
+    .trimEnd();
+  return `/** @noSelfInFile */\n${body}\n`;
+}
+
 export function wrapAsModule(opts: ModuleWrapOptions): string {
   // ambient-globals-only: the module form references engine handles (`Hash`,
   // `Vector3`, ...) as ambient globals and emits no top-level import. A top-level

package/src/script-api.ts

@@ -22,18 +22,12 @@ export interface RefDocConstantElement {
   name: string;
   brief: string;
   description: string;
+  /** The scalar's declared `type:` tokens; an engine `CONSTANT` carries none. */
+  types: string[];
 }
 
 export type RefDocElement = RefDocFunctionElement | RefDocConstantElement;
 
-export interface ScriptApiOptions {
-  // Also carry scalar members as CONSTANT elements and function `examples:` as
-  // ref-doc examples HTML, and nested callback arguments, table fields and
-  // optional flags on each slot. Off for the typing lanes, whose emitter and
-  // frozen goldens only ever see flat functions without examples.
-  complete?: boolean;
-}
-
 export interface RefDoc {
   info: { namespace: string; brief: string; description: string };
   elements: RefDocElement[];
@@ -47,6 +41,11 @@ function stringOr(value: unknown, fallback: string): string {
   return typeof value === "string" ? value : fallback;
 }
 
+// A `.script_api` spells a slot that takes one of a set of named constants as
+// `enum`; the core ref-doc token for the same meaning is `constant`, which the
+// emitter expands to the constants the slot's doc names.
+const TYPE_TOKEN_ALIASES: ReadonlyMap<string, string> = new Map([["enum", "constant"]]);
+
 // A `.script_api` `type:` may spell a union inline (`string | nil`), where the
 // core ref-doc format carries one token per alternative. Splitting here keeps the
 // downstream emitter and fidelity resolver working in single tokens. A `type:`
@@ -57,7 +56,8 @@ function splitTypeTokens(type: unknown): string[] {
   return type
     .split("|")
     .map((token) => token.trim())
-    .filter((token) => token.length > 0);
+    .filter((token) => token.length > 0)
+    .map((token) => TYPE_TOKEN_ALIASES.get(token) ?? token);
 }
 
 // Upstream writes a slot list either as a YAML list or, for a lone slot, as a
@@ -79,13 +79,12 @@ function isFunctionName(name: string): boolean {
   return name !== "None" && FUNCTION_NAME.test(name);
 }
 
-function mapSlot(item: Record<string, unknown>, complete: boolean): RefDocParameter {
+function mapSlot(item: Record<string, unknown>): RefDocParameter {
   const slot: RefDocParameter = {
     name: stringOr(item.name, "").replace(REQUIRED_SUFFIX, ""),
     doc: stringOr(item.desc, ""),
     types: splitTypeTokens(item.type),
   };
-  if (!complete) return slot;
   // A callback lists its arguments under `parameters:` and a table its keys under
   // `fields:` or `members:`; the ref-doc format carries all as `fields`. A
   // callback's own `self` is kept, since the engine really passes it to the callback.
@@ -94,18 +93,18 @@ function mapSlot(item: Record<string, unknown>, complete: boolean): RefDocParame
     ...slotList(item.fields),
     ...slotList(item.members),
   ];
-  if (nested.length > 0) slot.fields = nested.map((child) => mapSlot(child, complete));
+  if (nested.length > 0) slot.fields = nested.map(mapSlot);
   if (item.optional === true) slot.is_optional = "True";
   return slot;
 }
 
-function mapParameters(raw: unknown, complete: boolean): RefDocParameter[] {
+function mapParameters(raw: unknown): RefDocParameter[] {
   const out: RefDocParameter[] = [];
   for (const item of slotList(raw)) {
     // The script_api lists the implicit `self` the engine passes; the emitter
     // stamps @noSelfInFile, so generated signatures must not declare it.
     if (stringOr(item.name, "") === "self") continue;
-    out.push(mapSlot(item, complete));
+    out.push(mapSlot(item));
   }
   return out;
 }
@@ -153,22 +152,23 @@ function isScalar(member: Record<string, unknown>): boolean {
 
 /**
  * Convert a parsed Defold extension `.script_api` document into the core
- * ref-doc JSON object shape that `parseDefoldApiDoc` consumes. By default only
- * `type: function` members are carried; scalar members (constants) are
- * dropped, matching the core ref-doc pipeline where non-function elements
- * never reach the emitter. With `complete`, scalar members at the top level and
- * one table deep are also carried as CONSTANT elements, and each function's
- * `examples:` becomes `codehilite` examples HTML that keeps each fence's
- * language, and each slot's nested `parameters:`/`fields:` and `optional: true`
- * become ref-doc `fields` and `is_optional`, for the docs pages.
+ * ref-doc JSON object shape that `parseDefoldApiDoc` consumes. `type: function`
+ * members become FUNCTION elements; scalar members at the top level and one
+ * table deep become CONSTANT elements carrying their `type:` tokens, so a
+ * `type: string` scalar reaches the emitter as a string constant; each
+ * function's `examples:` becomes
+ * `codehilite` examples HTML that keeps each fence's language; and each slot's
+ * nested `parameters:`/`fields:` and `optional: true` become ref-doc `fields`
+ * and `is_optional`. The Libraries pages, the `script-api` lane, the extension
+ * goldens and `resolve` all read this one conversion.
  *
- * Upstream dialects are normalized in both modes: a function's slots are read
- * from the first present of `parameters:`, `params:` or `members:` and its
- * returns from `returns:` or `return:`, any slot list may be a single mapping,
- * a table slot's `members:` nest like `fields:`, a `(REQUIRED)` name suffix is
- * dropped, and a function named `None` or not a Lua identifier is skipped.
+ * Upstream dialects are normalized: a function's slots are read from the first
+ * present of `parameters:`, `params:` or `members:` and its returns from
+ * `returns:` or `return:`, any slot list may be a single mapping, a table slot's
+ * `members:` nest like `fields:`, a `(REQUIRED)` name suffix is dropped, and a
+ * function named `None` or not a Lua identifier is skipped.
  */
-export function scriptApiToRefDoc(parsed: unknown, options: ScriptApiOptions = {}): RefDoc {
+export function scriptApiToRefDoc(parsed: unknown): RefDoc {
   if (!Array.isArray(parsed)) {
     throw new Error("scriptApiToRefDoc: expected a top-level YAML list");
   }
@@ -193,13 +193,10 @@ export function scriptApiToRefDoc(parsed: unknown, options: ScriptApiOptions = {
       type: "FUNCTION",
       name,
       description: stringOr(member.desc, ""),
-      parameters: mapParameters(
-        member.parameters ?? member.params ?? member.members,
-        options.complete === true,
-      ),
-      returnvalues: mapParameters(member.returns ?? member.return, options.complete === true),
+      parameters: mapParameters(member.parameters ?? member.params ?? member.members),
+      returnvalues: mapParameters(member.returns ?? member.return),
     };
-    const examples = options.complete ? examplesHtml(member.examples) : "";
+    const examples = examplesHtml(member.examples);
     if (examples !== "") element.examples = examples;
     return element;
   };
@@ -211,6 +208,7 @@ export function scriptApiToRefDoc(parsed: unknown, options: ScriptApiOptions = {
     name,
     brief: stringOr(member.desc, ""),
     description: stringOr(member.desc, ""),
+    types: splitTypeTokens(member.type),
   });
   for (const member of members) {
     if (!isRecord(member)) continue;
@@ -219,7 +217,7 @@ export function scriptApiToRefDoc(parsed: unknown, options: ScriptApiOptions = {
       elements.push(fnElement(`${namespace}.${stringOr(member.name, "")}`, member));
       continue;
     }
-    if (options.complete && isScalar(member)) {
+    if (isScalar(member)) {
       elements.push(constantElement(`${namespace}.${stringOr(member.name, "")}`, member));
       continue;
     }
@@ -236,7 +234,7 @@ export function scriptApiToRefDoc(parsed: unknown, options: ScriptApiOptions = {
         if (subMember.type === "function") {
           if (isFunctionName(stringOr(subMember.name, "")))
             elements.push(fnElement(name, subMember));
-        } else if (options.complete && isScalar(subMember)) {
+        } else if (isScalar(subMember)) {
           elements.push(constantElement(name, subMember));
         }
       }
@@ -249,6 +247,6 @@ export function scriptApiToRefDoc(parsed: unknown, options: ScriptApiOptions = {
   return doc;
 }
 
-export function parseScriptApi(yamlText: string, options: ScriptApiOptions = {}): RefDoc {
-  return scriptApiToRefDoc(parse(yamlText), options);
+export function parseScriptApi(yamlText: string): RefDoc {
+  return scriptApiToRefDoc(parse(yamlText));
 }

package/src/socket-types.d.ts

@@ -9,7 +9,7 @@
 //
 //   const opt: socket.TCPOptions = 'keepalive';
 //   // TCP/UDP are convenience intersections for consumer annotations;
-//   // no socket.* function returns them (tcp() yields a `master` handle).
+//   // no socket.* function returns them (tcp() yields a `SocketMaster` handle).
 //
 // The literal unions are LuaSocket-domain, not engine-ref-doc, so they live
 // here rather than in the regen pipeline.
@@ -17,7 +17,7 @@
 declare global {
   namespace socket {
     /** A TCP handle in any of its three lifecycle roles. */
-    type TCP = client & master & server;
+    type TCP = SocketClient & SocketMaster & SocketServer;
     /** Option names accepted by a TCP handle's `setoption`. */
     type TCPOptions = "ipv6-v6only" | "keepalive" | "linger" | "reuseaddr" | "tcp-nodelay";
     /** Error string a TCP `receive` may return. */
@@ -29,7 +29,7 @@ declare global {
     /** Blocking mode passed to a TCP handle's `settimeout`. */
     type TCPTimeoutMode = "b" | "t";
     /** A UDP handle in either of its two lifecycle roles. */
-    type UDP = connected & unconnected;
+    type UDP = SocketConnected & SocketUnconnected;
     /** Option names accepted by a UDP handle's `setoption`. */
     type UDPOptions =
       | "broadcast"