@defold-typescript/types 0.4.2 → 0.5.0

package/generated/webview.d.ts

@@ -1,13 +1,63 @@
 /** @noSelfInFile */
 declare global {
   namespace webview {
+    /**
+     * Creates a webview instance. It can show HTML pages as well as evaluate Javascript. The view remains hidden until the first call. There can exist a maximum of 4 webviews at the same time.
+     * On iOS, the callback will never get a `webview.CALLBACK_RESULT_EVAL_ERROR`, due to the iOS SDK implementation."
+     *
+     * @param callback - A callback which receives info about finished requests taking the following parameters:
+     */
     function create(callback: (...args: unknown[]) => unknown): void;
+    /**
+     * Destroys an instance of a webview.
+     *
+     * @param webview_id - The webview id (returned by the `webview.create()` call)
+     */
     function destroy(webview_id: number): void;
+    /**
+     * Evaluates JavaScript within the context of the currently loaded page (if any). Once the request is done, the callback (registered in `webview.create()`) is invoked. The callback will get the result in the `data["result"]` field.
+     *
+     * @param webview_id - The webview id
+     * @param code - The JavaScript code to evaluate
+     */
     function eval(webview_id: number, code: string): void;
+    /**
+     * Returns the visibility state of the webview.
+     *
+     * @param webview_id - The webview id
+     */
     function is_visible(webview_id: number): void;
+    /**
+     * Opens a web page in the webview, using HTML data. Once the request is done, the callback (registered in `webview.create()`) is invoked.
+     *
+     * @param webview_id - The webview id
+     * @param html - The HTML data to display
+     * @param options - A table of options for the request. See `webview.open()`
+     */
     function open_raw(webview_id: number, html: string, options: Record<string | number, unknown>): void;
+    /**
+     * Sets the position and size of the webview
+     *
+     * @param webview_id - The webview id
+     * @param x - The x position of the webview
+     * @param y - The y position of the webview
+     * @param width - The width of the webview (-1 to match screen width)
+     * @param height - The height of the webview (-1 to match screen height)
+     */
     function set_position(webview_id: number, x: number, y: number, width: number, height: number): void;
+    /**
+     * Set transparency of webview background
+     *
+     * @param webview_id - The webview id
+     * @param transparent - If `true`, the webview background becomes transparent, otherwise opaque.
+     */
     function set_transparent(webview_id: number, transparent: boolean): void;
+    /**
+     * Shows or hides a webview
+     *
+     * @param webview_id - The webview id
+     * @param visible - If `0`, hides the webview. If non zero, shows the view
+     */
     function set_visible(webview_id: number, visible: number): void;
   }
 }

package/generated/window.d.ts

@@ -3,24 +3,165 @@ import type { Opaque } from "../src/core-types";
 
 declare global {
   namespace window {
+    /**
+     * Dimming mode is used to control whether or not a mobile device should dim the screen after a period without user interaction.
+     */
     const DIMMING_OFF: number & { readonly __brand: "window.DIMMING_OFF" };
+    /**
+     * Dimming mode is used to control whether or not a mobile device should dim the screen after a period without user interaction.
+     */
     const DIMMING_ON: number & { readonly __brand: "window.DIMMING_ON" };
+    /**
+     * Dimming mode is used to control whether or not a mobile device should dim the screen after a period without user interaction.
+     * This mode indicates that the dim mode can't be determined, or that the platform doesn't support dimming.
+     */
     const DIMMING_UNKNOWN: number & { readonly __brand: "window.DIMMING_UNKNOWN" };
+    /**
+     * This event is sent to a window event listener when the game window or app screen is
+     * restored after being iconified.
+     */
     const WINDOW_EVENT_DEICONIFIED: number & { readonly __brand: "window.WINDOW_EVENT_DEICONIFIED" };
+    /**
+     * This event is sent to a window event listener when the game window or app screen has
+     * gained focus.
+     * This event is also sent at game startup and the engine gives focus to the game.
+     */
     const WINDOW_EVENT_FOCUS_GAINED: number & { readonly __brand: "window.WINDOW_EVENT_FOCUS_GAINED" };
+    /**
+     * This event is sent to a window event listener when the game window or app screen has lost focus.
+     */
     const WINDOW_EVENT_FOCUS_LOST: number & { readonly __brand: "window.WINDOW_EVENT_FOCUS_LOST" };
+    /**
+     * This event is sent to a window event listener when the game window or app screen is
+     * iconified (reduced to an application icon in a toolbar, application tray or similar).
+     */
     const WINDOW_EVENT_ICONFIED: number & { readonly __brand: "window.WINDOW_EVENT_ICONFIED" };
+    /**
+     * This event is sent to a window event listener when the game window or app screen is resized.
+     * The new size is passed along in the data field to the event listener.
+     */
     const WINDOW_EVENT_RESIZED: number & { readonly __brand: "window.WINDOW_EVENT_RESIZED" };
+    /**
+     * Returns the current dimming mode set on a mobile device.
+     * The dimming mode specifies whether or not a mobile device should dim the screen after a period without user interaction.
+     * On platforms that does not support dimming, `window.DIMMING_UNKNOWN` is always returned.
+     *
+     * @returns The mode for screen dimming
+  - `window.DIMMING_UNKNOWN`
+  - `window.DIMMING_ON`
+  - `window.DIMMING_OFF`
+     */
     function get_dim_mode(): Opaque<"constant">;
+    /**
+     * This returns the content scale of the current display.
+     *
+     * @returns The display scale
+     */
     function get_display_scale(): number;
+    /**
+     * This returns the current lock state of the mouse cursor
+     *
+     * @returns The lock state
+     */
     function get_mouse_lock(): boolean;
+    /**
+     * This returns the safe area rectangle (x, y, width, height) and the inset
+     * values relative to the window edges. On platforms without a safe area,
+     * this returns the full window size and zero insets.
+     *
+     * @returns safe area data
+  `safe_area`
+  table table containing these keys:
+  - number `x`
+  - number `y`
+  - number `width`
+  - number `height`
+  - number `inset_left`
+  - number `inset_top`
+  - number `inset_right`
+  - number `inset_bottom`
+     */
     function get_safe_area(): { safe_area: { x: number; y: number; width: number; height: number; inset_left: number; inset_top: number; inset_right: number; inset_bottom: number } };
+    /**
+     * This returns the current window size (width and height).
+     */
     function get_size(): LuaMultiReturn<[number, number]>;
+    /**
+     * Sets the dimming mode on a mobile device.
+     * The dimming mode specifies whether or not a mobile device should dim the screen after a period without user interaction. The dimming mode will only affect the mobile device while the game is in focus on the device, but not when the game is running in the background.
+     * This function has no effect on platforms that does not support dimming.
+     *
+     * @param mode - The mode for screen dimming
+  - `window.DIMMING_ON`
+  - `window.DIMMING_OFF`
+     */
     function set_dim_mode(mode: Opaque<"constant">): void;
+    /**
+     * Sets a window event listener. Only one window event listener can be set at a time.
+     *
+     * @param callback - A callback which receives info about window events. Pass an empty function or `nil` if you no longer wish to receive callbacks.
+  `self`
+  object The calling script
+  `event`
+  constant The type of event. Can be one of these:
+  - `window.WINDOW_EVENT_FOCUS_LOST`
+  - `window.WINDOW_EVENT_FOCUS_GAINED`
+  - `window.WINDOW_EVENT_RESIZED`
+  - `window.WINDOW_EVENT_ICONIFIED`
+  - `window.WINDOW_EVENT_DEICONIFIED`
+  `data`
+  table The callback value `data` is a table which currently holds these values
+  - number `width`: The width of a resize event. nil otherwise.
+  - number `height`: The height of a resize event. nil otherwise.
+     * @example
+     * ```lua
+     * function window_callback(self, event, data)
+     *     if event == window.WINDOW_EVENT_FOCUS_LOST then
+     *         print("window.WINDOW_EVENT_FOCUS_LOST")
+     *     elseif event == window.WINDOW_EVENT_FOCUS_GAINED then
+     *         print("window.WINDOW_EVENT_FOCUS_GAINED")
+     *     elseif event == window.WINDOW_EVENT_ICONFIED then
+     *         print("window.WINDOW_EVENT_ICONFIED")
+     *     elseif event == window.WINDOW_EVENT_DEICONIFIED then
+     *         print("window.WINDOW_EVENT_DEICONIFIED")
+     *     elseif event == window.WINDOW_EVENT_RESIZED then
+     *         print("Window resized: ", data.width, data.height)
+     *     end
+     * end
+     *
+     * function init(self)
+     *     window.set_listener(window_callback)
+     * end
+     * ```
+     */
     function set_listener(callback?: (self: unknown, event: unknown, data: unknown) => void): void;
+    /**
+     * Set the locking state for current mouse cursor on a PC platform.
+     * This function locks or unlocks the mouse cursor to the center point of the window. While the cursor is locked,
+     * mouse position updates will still be sent to the scripts as usual.
+     *
+     * @param flag - The lock state for the mouse cursor
+     */
     function set_mouse_lock(flag: boolean): void;
+    /**
+     * Sets the window position.
+     *
+     * @param x - Horizontal position of window
+     * @param y - Vertical position of window
+     */
     function set_position(x: number, y: number): void;
+    /**
+     * Sets the window size. Works on desktop platforms only.
+     *
+     * @param width - Width of window
+     * @param height - Height of window
+     */
     function set_size(width: number, height: number): void;
+    /**
+     * Sets the window title. Works on desktop platforms.
+     *
+     * @param title - The title, encoded as UTF-8
+     */
     function set_title(title: string): void;
   }
 }

package/generated/zlib.d.ts

@@ -1,7 +1,35 @@
 /** @noSelfInFile */
 declare global {
   namespace zlib {
+    /**
+     * A lua error is raised is on error
+     *
+     * @param buf - buffer to deflate
+     * @returns deflated buffer
+     * @example
+     * ```lua
+     * local data = "This is a string with uncompressed data."
+     * local compressed_data = zlib.deflate(data)
+     * local s = ""
+     * for c in string.gmatch(compressed_data, ".") do
+     *     s = s .. '\\' .. string.byte(c)
+     * end
+     * print(s) --> \120\94\11\201\200\44\86\0\162\68\133\226\146\162 ...
+     * ```
+     */
     function deflate(buf: string): string;
+    /**
+     * A lua error is raised is on error
+     *
+     * @param buf - buffer to inflate
+     * @returns inflated buffer
+     * @example
+     * ```lua
+     * local data = "\120\94\11\201\200\44\86\0\162\68\133\226\146\162\204\188\116\133\242\204\146\12\133\210\188\228\252\220\130\162\212\226\226\212\20\133\148\196\146\68\61\0\44\67\14\201"
+     * local uncompressed_data = zlib.inflate(data)
+     * print(uncompressed_data) --> This is a string with uncompressed data.
+     * ```
+     */
     function inflate(buf: string): string;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defold-typescript/types",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "TypeScript types for the Defold engine's Lua APIs.",
   "license": "MIT",
   "type": "module",

package/src/api-doc.ts

@@ -12,6 +12,8 @@ export interface ApiModule {
 export interface ApiProperty {
   name: string;
   types: string[];
+  brief: string;
+  description: string;
 }
 
 export interface ApiTypedef {
@@ -30,6 +32,7 @@ export interface ApiFunction {
   description: string;
   parameters: ApiParameter[];
   returnValues: ApiParameter[];
+  examples?: string;
 }
 
 export interface ApiParameter {
@@ -99,7 +102,12 @@ function parseProperty(element: Record<string, unknown>): ApiProperty {
           .map((t) => t.trim())
           .filter((t) => t.length > 0)
       : [];
-  return { name: stringOr(element.name, ""), types };
+  return {
+    name: stringOr(element.name, ""),
+    types,
+    brief,
+    description: stringOr(element.description, ""),
+  };
 }
 
 function parseConstant(element: Record<string, unknown>): ApiConstant {
@@ -117,6 +125,7 @@ function parseFunction(element: Record<string, unknown>): ApiFunction {
     description: stringOr(element.description, ""),
     parameters: parseParameterList(element.parameters),
     returnValues: parseParameterList(element.returnvalues),
+    examples: stringOr(element.examples, ""),
   };
 }
 

package/src/doc-comment.ts

@@ -0,0 +1,119 @@
+const NAMED_ENTITIES: Record<string, string> = {
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&apos;": "'",
+};
+
+function decodeEntities(text: string): string {
+  let out = text;
+  for (const [entity, char] of Object.entries(NAMED_ENTITIES)) {
+    out = out.split(entity).join(char);
+  }
+  out = out.replace(/&#(\d+);/g, (_, code) => String.fromCharCode(Number(code)));
+  // `&amp;` last so an already-decoded `&` is never re-interpreted.
+  return out.split("&amp;").join("&");
+}
+
+/**
+ * Convert a ref-doc HTML fragment to clean Markdown/plain text suitable for a
+ * JSDoc comment body. Pure and free of any `ApiModule` dependency so the emit
+ * slices and any future surface can reuse it.
+ */
+export function htmlToDocText(html: string): string {
+  let text = html
+    .replace(/<code>([\s\S]*?)<\/code>/gi, "`$1`")
+    .replace(/<(?:em|i)>([\s\S]*?)<\/(?:em|i)>/gi, "*$1*")
+    .replace(/<a\b[^>]*>([\s\S]*?)<\/a>/gi, "$1")
+    .replace(/<li>/gi, "\n- ")
+    .replace(/<\/li>/gi, "")
+    .replace(/<br\s*\/?>/gi, "\n")
+    .replace(/<\/?pre>/gi, "\n")
+    .replace(/<[^>]+>/g, "");
+
+  text = decodeEntities(text);
+
+  // Collapse horizontal whitespace runs, trim around newlines, drop blank
+  // runs, then trim the whole string — preserving single newlines from lists
+  // and `<br>`.
+  text = text
+    .replace(/[ \t]+/g, " ")
+    .replace(/ *\n */g, "\n")
+    .replace(/\n{2,}/g, "\n")
+    .trim();
+
+  // A literal `*/` would close the JSDoc comment early; escape it.
+  return text.split("*/").join("*\\/");
+}
+
+/**
+ * Convert a syntax-highlighted ref-doc code fragment (the `examples` field's
+ * `<div class="codehilite">…</div>` markup) to plain source. Unlike
+ * `htmlToDocText` this preserves line structure and indentation — collapsing or
+ * trimming per line would make the sample unreadable — stripping only highlight
+ * markup, per-line trailing whitespace, and surrounding blank lines, and folding
+ * runs of blank lines to one. Returns `""` for empty / whitespace-only input.
+ */
+export function htmlToCodeText(html: string): string {
+  let text = html.replace(/<br\s*\/?>/gi, "\n").replace(/<[^>]+>/g, "");
+  text = decodeEntities(text);
+
+  const lines = text.split("\n").map((line) => line.replace(/[ \t]+$/g, ""));
+  while (lines.length > 0 && lines[0] === "") lines.shift();
+  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  const collapsed = lines.join("\n").replace(/\n{3,}/g, "\n\n");
+
+  // A literal `*/` inside sample code would close the JSDoc comment early.
+  return collapsed.split("*/").join("*\\/");
+}
+
+export interface DocCommentParts {
+  summary: string;
+  params?: { name: string; doc: string }[];
+  returns?: string;
+  example?: string;
+}
+
+/**
+ * Build the JSDoc line array (no indentation) for the given parts. Returns `[]`
+ * when there is nothing to document so the caller can emit nothing.
+ */
+export function renderDocComment(parts: DocCommentParts): string[] {
+  const summaryLines = parts.summary.trim() === "" ? [] : parts.summary.split("\n");
+  const params = (parts.params ?? []).filter((p) => p.doc.trim() !== "");
+  const returns = parts.returns?.trim() ? parts.returns : "";
+  const example = parts.example?.trim() ? parts.example : "";
+
+  if (summaryLines.length === 0 && params.length === 0 && returns === "" && example === "") {
+    return [];
+  }
+
+  const lines = ["/**"];
+  for (const line of summaryLines) {
+    lines.push(` * ${line}`);
+  }
+
+  const hasTags = params.length > 0 || returns !== "" || example !== "";
+  if (summaryLines.length > 0 && hasTags) {
+    lines.push(" *");
+  }
+
+  for (const param of params) {
+    lines.push(` * @param ${param.name} - ${param.doc}`);
+  }
+  if (returns !== "") {
+    lines.push(` * @returns ${returns}`);
+  }
+  if (example !== "") {
+    lines.push(" * @example");
+    lines.push(" * ```lua");
+    for (const line of example.split("\n")) {
+      lines.push(line === "" ? " *" : ` * ${line}`);
+    }
+    lines.push(" * ```");
+  }
+
+  lines.push(" */");
+  return lines;
+}

package/src/emit-dts.ts

@@ -7,6 +7,12 @@ import type {
   ApiVariable,
 } from "./api-doc";
 import { DEFOLD_TYPE_MAP } from "./core-types";
+import {
+  type DocCommentParts,
+  htmlToCodeText,
+  htmlToDocText,
+  renderDocComment,
+} from "./doc-comment";
 
 export interface EmitOptions {
   mapType?: (defoldType: string) => string;
@@ -473,6 +479,9 @@ export function emitDeclarations(module: ApiModule, options?: EmitOptions): stri
     lines.push(`${INDENT}${decl}type ${t.name} = Opaque<"${t.name}">;`);
   }
   for (const c of constants) {
+    for (const docLine of summaryDocLines(c.original.brief, c.original.description, INDENT)) {
+      lines.push(docLine);
+    }
     lines.push(`${INDENT}${decl}const ${c.name}: ${brandType(c.fqn)};`);
   }
   const aliases: { internal: string; public: string }[] = [];
@@ -483,11 +492,17 @@ export function emitDeclarations(module: ApiModule, options?: EmitOptions): stri
     const reserved = TS_RESERVED_NAMES.has(v.name);
     const emitName = aliasName(v.name, aliases);
     const line = emitVariable(v, emitName, mapType);
-    if (line !== null) lines.push(`${INDENT}${reserved ? "" : decl}${line}`);
+    if (line !== null) {
+      for (const docLine of summaryDocLines(v.original.brief, v.original.description, INDENT)) {
+        lines.push(docLine);
+      }
+      lines.push(`${INDENT}${reserved ? "" : decl}${line}`);
+    }
   }
   for (const fn of functions) {
     const reserved = TS_RESERVED_NAMES.has(fn.name);
     const emitName = aliasName(fn.name, aliases);
+    for (const docLine of functionDocLines(fn.original)) lines.push(docLine);
     const line = emitFunction(fn, emitName, mapType, resolver);
     lines.push(`${INDENT}${reserved ? "" : decl}${line}`);
   }
@@ -500,6 +515,9 @@ export function emitDeclarations(module: ApiModule, options?: EmitOptions): stri
     const members = [...module.properties].sort((a, b) => a.name.localeCompare(b.name));
     lines.push(`${INDENT}${decl}interface properties {`);
     for (const p of members) {
+      for (const docLine of summaryDocLines(p.brief, p.description, `${INDENT}${INDENT}`)) {
+        lines.push(docLine);
+      }
       lines.push(`${INDENT}${INDENT}${emitPropertyMember(p, mapType)}`);
     }
     lines.push(`${INDENT}}`);
@@ -512,6 +530,7 @@ export function emitDeclarations(module: ApiModule, options?: EmitOptions): stri
 interface PreparedConstant {
   name: string;
   fqn: string;
+  original: ApiConstant;
 }
 
 interface PreparedFunction {
@@ -533,7 +552,7 @@ function prepareFunction(fn: ApiFunction, prefix: string): PreparedFunction | nu
 function prepareConstant(c: ApiConstant, prefix: string): PreparedConstant | null {
   const stripped = stripPrefix(c.name, prefix);
   if (!TS_IDENTIFIER.test(stripped)) return null;
-  return { name: stripped, fqn: c.name };
+  return { name: stripped, fqn: c.name, original: c };
 }
 
 function brandType(fqn: string): string {
@@ -589,6 +608,48 @@ function emitFunction(
   return `function ${name}(${params}): ${ret.type};${ret.trailing}`;
 }
 
+// Build the indented JSDoc lines for a function from its ref-doc prose. The
+// summary prefers the full `description`, falling back to the one-line `brief`;
+// each `@param` name is the parameter's *emitted* name (the `arg<index>`
+// fallback applies to non-identifier names, matching `emitParameter`) so the tag
+// resolves on hover; a single documented return becomes `@returns`. Returns `[]`
+// for a fully-undocumented function, leaving its emission byte-identical.
+function functionDocLines(fn: ApiFunction): string[] {
+  const params = fn.parameters.map((p, index) => ({
+    name: TS_IDENTIFIER.test(p.name) ? p.name : `arg${index}`,
+    doc: htmlToDocText(p.doc),
+  }));
+  const onlyReturn = fn.returnValues.length === 1 ? fn.returnValues[0] : undefined;
+  const example = htmlToCodeText(fn.examples ?? "");
+  const parts: DocCommentParts = {
+    summary: htmlToDocText(summaryFor(fn.brief, fn.description)),
+    params,
+    ...(onlyReturn ? { returns: htmlToDocText(onlyReturn.doc) } : {}),
+    ...(example !== "" ? { example } : {}),
+  };
+  return indentDocLines(parts, INDENT);
+}
+
+// Summary-only doc lines for a member that carries no params or returns
+// (constants, variables, `properties` members). Reuses the same renderer and
+// summary precedence as functions; returns `[]` for an undocumented member so
+// its emission stays byte-identical. `indent` matches the member's own
+// indentation depth (one level inside the namespace, two inside `properties`).
+function summaryDocLines(brief: string, description: string, indent: string): string[] {
+  return indentDocLines({ summary: htmlToDocText(summaryFor(brief, description)) }, indent);
+}
+
+function indentDocLines(parts: DocCommentParts, indent: string): string[] {
+  return renderDocComment(parts).map((line) => `${indent}${line}`);
+}
+
+// Prefer the full `description`; fall back to the one-line `brief` when prose is
+// absent. Shared by every documented member kind so the summary source is
+// consistent across functions, constants, variables, and properties.
+function summaryFor(brief: string, description: string): string {
+  return description.trim() !== "" ? description : brief;
+}
+
 function isDocOptional(p: ApiParameter): boolean {
   return p.isOptional || p.types.includes("nil");
 }

package/src/index.ts

@@ -10,6 +10,7 @@ export {
   type Vector3,
   type Vector4,
 } from "./core-types";
+export { type DocCommentParts, htmlToDocText, renderDocComment } from "./doc-comment";
 export { type EmitOptions, emitDeclarations } from "./emit-dts";
 export {
   defineGuiScript,

package/src/lifecycle.ts

@@ -1,9 +1,5 @@
 import type { Hash, Url } from "./core-types";
 
-type OnMessagePayload<K> = K extends BuiltinMessageId
-  ? BuiltinMessages[K]
-  : Record<string | number, unknown>;
-
 export interface InputTouch {
   id?: number;
   pressed?: boolean;
@@ -46,10 +42,15 @@ export interface InputAction {
 export interface ScriptHooks<TSelf> {
   init?(self: TSelf): void;
   update?(self: TSelf, dt: number): void;
-  on_message?<K extends string>(
+  fixed_update?(self: TSelf, dt: number): void;
+  late_update?(self: TSelf, dt: number): void;
+  // Defold delivers message_id as a pre-hashed `hash`, so handlers must compare
+  // it against `hash("...")` constants — a string literal never matches. Sender-
+  // side payload narrowing by message id lives on `msg.post` (msg-overloads.d.ts).
+  on_message?(
     self: TSelf,
-    message_id: K,
-    message: OnMessagePayload<K>,
+    message_id: Hash,
+    message: Record<string | number, unknown>,
     sender: Url,
   ): void;
   on_input?(
@@ -62,6 +63,26 @@ export interface ScriptHooks<TSelf> {
   on_reload?(self: TSelf): void;
 }
 
+export const SCRIPT_HOOK_NAMES = [
+  "init",
+  "update",
+  "fixed_update",
+  "late_update",
+  "on_message",
+  "on_input",
+  "final",
+  "on_reload",
+] as const;
+
+export type ScriptHookName = (typeof SCRIPT_HOOK_NAMES)[number];
+
+type Equal<A, B> =
+  (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
+
+// drift-pin: SCRIPT_HOOK_NAMES must list exactly the ScriptHooks members
+const _hookNamesPinnedToInterface: Equal<ScriptHookName, keyof ScriptHooks<unknown>> = true;
+void _hookNamesPinnedToInterface;
+
 export type GuiScriptHooks<TSelf> = ScriptHooks<TSelf>;
 
 export type RenderScriptHooks<TSelf> = Omit<ScriptHooks<TSelf>, "on_input">;