Skip to Content
defold-typescript
Get startedGuidesAPILibraries
Releases

Changelog

What changed in each published defold-typescript toolchain release.

Tip

Upgrading the toolchain and upgrading your pinned Defold target are independent moves.

v0.68.0 - 2026-11-20

Summary:

Improved

  • Property keys and values are checked against what the target declares:
    • go.animate checks its target value against the property: on a transform key a number fills a vector such as "position" and "rotation" takes only a quaternion, and go.animate<P>() takes a component catalog such as sprite.Properties or a ScriptPropertiesOf shape and accepts only the keys the engine can animate. go.set rejects a wrong value on a transform key too, such as a quaternion for "position", instead of accepting it as an untyped write (Component properties).
    • go.get, go.set and go.animate type a property key by its address: scene-types writes each component address that names no compiled script as its kind, such as "sprite", instead of true, so a linked script's address takes only its declared properties, a sprite, label, model, mesh, collision object, factory, collection factory, particle effect, sound, tile map, camera (Defold 1.13.0 and later) or gui address types its catalog's keys, and a literal with no #, such as ".", takes only the transform keys. An extension can register its own kind in SceneComponentCatalogs (Scene types).
    • factory.create and collectionfactory.create check the spawned scripts' properties in their curried forms: factory.create<P>() takes a ScriptPropertiesOf shape as P and collectionfactory.create<P>() maps each instance id, such as "/enemy_leader", to one, so an unknown id, an undeclared name or a wrongly typed value in properties is a type error. The build removes the empty call and hashes each instance id, and reports a stored collectionfactory.create<P>() or a properties value that is not an object literal as an error (Component properties).

Fixed

  • Calls the engine raises on, ignores or animates wrongly are type errors:
    • collectionfactory.create takes instance ids as hashes only: its properties is a map keyed by hash("/enemy"), such as a LuaMap<Hash, EnemyProps>, so an object literal keyed by id strings, which the engine raised on at spawn, is a type error; collectionfactory.create<P>() takes the ids as strings and hashes them (Component properties).
    • factory.create and each collectionfactory.create instance table take a LuaMap of properties only when it is keyed by name strings and holds property values, so a hash("speed") key, which the engine skipped, or a Matrix4 value, which made it drop every property, is a type error (Component properties).
    • gui.animate checks its target against the property the way the engine reads it: "rotation" takes only a quaternion, so a vector3 or a number, which animated to a distorted rotation, is a type error, and a sub-key such as "position.x" or a scalar such as "fill_angle" takes only a number (GUI node properties).
    • gui.cancel_animations and go.cancel_animations reject a property name the engine raises on, such as "positon": gui.cancel_animations takes the names gui.animate takes, and go.cancel_animations the keys a literal address can animate, so a script property holding a Hash is a type error too (Component properties).
    • gui.get and gui.set take an options table holding one of index, key or keys, so a table holding two, which the engine raised on, is a type error (GUI node properties).
    • physics.set_shape on Defold 1.13.2 and later takes one table per shape kind, so a box without dimensions or a hull shape, which the engine raised on, is a type error.
    • sys.save and sys.serialize reject a LuaMap or LuaTable keyed by anything but a string, number or Hash, which the engine raised on.
  • http.request accepts the proxy option the engine reads on native builds, which was a type error.
  • Wrapped and optional calls to onMessage, defineScript and the resource markers build like the bare call: onMessage?.() and (onMessage)() report an error instead of crashing the build and the editor's diagnostics, onMessage!({...}) and a hook written (onMessage)({...}) lower, onMessage?.(handlers) squiggles once, and a resource.atlas default inside (defineScript)({...}) compiles. A marker call such as (resource.atlas)("/a.atlas") outside a property default fails the build like resource.atlas("/a.atlas") (Which handler forms build).
  • A component address stays untyped when the components behind it disagree: scene-types writes it as true when two objects in the collection a factory spawns give a bare #id different scripts or kinds, or when two proxied collections sharing one socket declare a path such as "level:/hero#body" differently. msg.post, go.get, go.set and go.animate then check it against no single one of those components (Scene types).
  • The docs sites show pages as written:
    • Code blocks on both sites show at full length instead of scrolling inside a 600px frame, and the copy button shows a hand cursor on hover.
    • The page outline on both sites keeps each heading's inline code, bold, italic and struck text instead of plain text.
    • The API landing page leaves space between each group's description and its cards.
    • Linked badges, such as those atop the Overview page, show without a link underline.

v0.67.0 - 2026-11-18

Summary:

  • build deletes the runtime files nothing requires and keeps every file your sources compile to, under any letter case (Build).
  • Both docs sites have a new Fumadocs layout with in-browser search and guide and API pages rendered with Fumadocs' code blocks and callouts, and the toolchain site has section tabs and the API version range picker in the sidebar (API reference, library docs).
  • build, watch and the editor warn on a top-level name that hides a Lua or Defold global, such as a helper named select, and build and watch print the direct go.property call warning (TypeScript gotchas).

Improved

  • build, watch and the editor warn when a top-level name you do not export hides a Lua or Defold global, such as a helper named select or next, an enum go, or an import the file reads as a value, since each compiles to a Lua local that also catches the Lua the build generates in that file. The warning names the file, line and column, and the build still succeeds (TypeScript gotchas).

  • The docs site has a new layout built on Fumadocs, with Get started, Guides, API and Libraries as tabs in a bar that stays at the top of the page, Get started opening on the Overview and Guides and API on a landing page, a page outline that shows each API signature in its syntax colors, a sidebar that lists every link of its tab in the page's HTML, closed folders included, with the API version range picker at its top, whose saved range or a link's ?since= the sidebar's count pills and the outline's change chips follow, and guide and API pages rendered with Fumadocs' code blocks, callouts and code tabs, guides under the heading anchors GitHub gives the same file. A search dialog (Ctrl+K or ⌘K) runs in the browser, tolerates a typo, finds API members by full or bare name, such as gui.animate or animate, from the engine version of the page you are on, and shows each hit as the passage around your words, opening the member or the guide section under any heading it matched, or from its footer a /search page of up to 30 hits that you can link to.

  • The library docs site has the same Fumadocs layout, with its guides and every library grouped by owner in a sidebar that lists all of them in each page's HTML, closed folders included, the Toolchain docs and GitHub links beside them, a page outline that shows each API signature in its syntax colors, and the toolchain site's search dialog, which runs in the browser, tolerates a typo, finds library members by full or bare name, untyped libraries and guide sections, and shows each hit as the passage around your words, opening the section or member it matched or, from its footer, the site's /search page. Guide and API pages render with Fumadocs' code blocks, callouts and code tabs, each code block with a copy button and light and dark highlighting, and guides keep the heading anchors GitHub gives the same file.

Fixed

  • build and watch print the warning for a direct go.property call, naming the file, and build --json carries it in warnings (Why not call go.property yourself).
  • The API reference heading of window.set_listener shows its whole signature in its syntax colors, which the backticks in its event type cut short, and links its window.EventData type.
  • A build with no errors deletes the runtime files nothing requires any more, such as a lualib_bundle.lua an earlier failing build wrote, or timers.lua and hsm/<module>.lua once no source imports them; a file stays when it lacks the generated banner, when a source of yours compiles to that file, including under a differently cased name on macOS and Windows, or when a hand-written Lua or script file requires it by name, and a file kept that way keeps the runtime files it requires. build names the deleted files on a second line and build --json lists them in removed, while a failing build and a watch rebuild delete nothing (Build, Agent runbooks).
  • On macOS and Windows, build and watch keep a source output whose path differs only in letter case from a runtime file an earlier version wrote at the output root, such as Defold_Typescript_Timers.lua beside defold_typescript_timers.lua, instead of deleting it right after writing it (Build).
  • An API reference URL whose ?since= names the oldest tracked release keeps that From when the docs site moves it onto your saved To, instead of replacing it with the From you last picked (Reading the API reference over a range).

v0.66.0 - 2026-11-15

Summary:

  • Breaking: build skips everything under src/test/, so game code there moves out (build).
  • Bun tests sit next to their modules or in src/test/, which upgrade scaffolds and defold-typescript:typecheck checks, and stay out of the build (Test with Bun).
  • build --json adds lualibRequiredBy, and agents check .gui edits (runbooks, build).
  • init and upgrade keep a tsconfig.json's comments and extends (init).
  • Walls clear outDir, the starter scene parses, the debug launcher type-checks, and TypeScriptToLua 1.37.2 fixes several Lua output bugs (wall, debugging).

Breaking

  • build, watch and wall skip everything under src/test/, the folder for tests and helpers that need Bun's runtime: a module there writes no Lua and joins no program the build type-checks, so game code in that folder moves out. A wall at src excludes the folder; run wall src to rewrite an existing one (Build, Wall).

Added

  • Bun tests type-check against the game's own types, without Bun's globals reaching game code, in either of two places:
    • Next to the module it tests: build, watch and the editor plugin skip every *.test.ts, *_test.ts, *.spec.ts or *_spec.ts file under the source roots, so it writes no Lua and gets no build diagnostic. Starting it with /// <reference types="bun-types/test" /> lets the project's own tsc --noEmit check it (Build).
    • In src/test/, for tests that need node:* or Bun: init and upgrade write src/test/tsconfig.json, which extends the root config, and src/test/env.d.ts, which references bun-types, add src/test to the root exclude, and bring a hand-made test config onto the same settings, replacing its include and exclude only when they select other files; the defold-typescript:typecheck mise task then runs tsc --noEmit -p src/test/tsconfig.json after the root check, with or without a root outDir. Each edit, a Bun older than the bun-types pin or different from an exact project pin, and Bun tests under test/ or tests/ get one warning (Test with Bun).
    • The Test with Bun guide page explains where a test goes, each src/test/ setting and how to stub engine calls; the managed AGENTS.md block and the Write a test runbook point to it.
  • build --json reports which outputs require the TypeScript runtime helper bundle: a successful result always carries lualibRequiredBy, the sorted output paths whose Lua requires lualib_bundle, including files this run left unchanged, so a project that avoids the bundle can check it without scanning its output folder (Agent runbooks).

Improved

  • The agent contract and the package llms.txt tell an agent how to check Defold resource edits: type-checking and a plain build do not fully validate or compile .gui or .collection files, so they point at build --editor-compile --json with the editor open. They also list @defold-typescript/types/src/lifecycle.ts for script callback payloads such as InputAction (Install the agent contract, Compile in the editor).
  • A new project lists bun-types at the exact version 1.4.4 in place of @types/bun, and upgrade adds it beside an existing @types/bun entry, which stays (Helper scripts).

Fixed

  • A root tsconfig.json with a comment or trailing comma made init, upgrade, build and wall fail, init --force and upgrade deleted its extends, references and files, and the .vscode/*.json merges dropped comments. Every config the CLI edits now changes one key or entry at a time, and build, the editor plugin and the merge count settings inherited through extends (Init).
  • The .vscode/defold-debug.ts launcher reported Cannot find name 'node:fs' under the project's TypeScript 6: it now references bun-types itself, and upgrade refreshes an unedited launcher (Debugging).
  • A walled directory whose source imports a module outside it reported TS6059 in the editor and in wall --check when the root tsconfig.json sets outDir. Each wall now sets outDir to null; run wall <dir> once for any walled directory to rewrite existing walls (Wall).
  • A fresh project's main/main.collection could not be parsed: build printed three warnings and skipped the unreachable-address check, and scene-types left /main out of .defold-types/scene-addresses.d.ts. A scene file with several fields on one line now reads the way Defold reads it (Scene types).
  • Several Lua output bugs from the TypeScriptToLua compiler: the transpiler now requires TypeScriptToLua 1.37.2, which fixes -(-x) printing as a Lua comment, break and continue inside a try within a loop, and @noSelf on interfaces with call signatures.
  • bun audit could flag the CLI's hono and @hono/node-server dependencies: the CLI now requires hono 4.13.18 and @hono/node-server 2.1.8 or newer, which close the published advisories.

v0.65.0 - 2026-11-13

Summary:

  • gameanalytics follows GA-SDK-DEFOLD 5.0.0 (resolve).
  • Docs code tabs and tooltips work on long pages (vmath).

Improved

  • The gameanalytics types follow GameAnalytics/GA-SDK-DEFOLD tag 5.0.0: they add the user and A/B-testing id getters with gameanalytics.setExternalUserId, the session-time getters, the number and JSON remote-config reads, and four health-event toggles such as gameanalytics.enableFpsHistogram. gameanalytics.addBusinessEvent accepts receipt, signature and autoFetchReceipt on every platform.

Fixed

  • Code tabs, copy buttons, hover tooltips and live state machine demos could stay dead on a long docs page when the end of the page arrived after the site's script had run, which a cached script makes likely: Opera on Windows showed it on the Config/Builder tabs of the State machines guide and the TypeScript/Lua tabs of reference pages such as vmath. Every page now sets them up once it has fully loaded.

v0.64.0 - 2026-11-12

Summary:

  • onMessage handlers and hooks bind every parameter and module-level name at runtime, and a defaulted one fails the build (Which handler forms build).

Breaking

  • A defaulted onMessage handler or lifecycle hook parameter, such as update(self, dt = 0), fails the build with an error at that parameter, since the default never took effect. Default it inside the body (Which handler forms build).

Fixed

  • onMessage handlers and lifecycle hooks built clean but read the wrong value or an undefined global when Defold ran them: a handler reading its self parameter or a module-level message, sender or message_id, a parameter TypeScript-to-Lua renames such as type, handler parameters named after another engine argument such as (message, msg), and an optional parameter past the engine's arguments on a handler or a returning init. A handler now reads every module-level name it uses and each parameter holds the engine argument at its position, or undefined past them, while a destructured or rest parameter, which emitted broken Lua, fails the build at that parameter (Routing many messages, Reading properties in init).

v0.63.0 - 2026-11-12

Summary:

  • bun test runs hsm and ecs from a plain import (State machines).
  • build and tsc agree on onMessage, socket aliases and the API and libraries an editor or game script may use (Editor scripts).
  • Interface values pass as tables to sys.save and every PlainTable slot on all targets.
  • Clean scaffolds that upgrade keeps current: docs paths, .gitignore and Biome (init).
  • Symbolic links and outDir: build and watch compile a linked folder an include pattern reaches inside the repository or a link-roots folder, build, watch and resolve refuse to write through a link or outside the project, and an outDir Defold never loads, or a source inside outDir, fails build and watch (Linked source folders).

Breaking

  • An outDir Defold never loads is rejected, and a source inside outDir fails. A tsconfig.json outDir that is absolute, climbs out with .., or is or sits inside a root build, builtins, .internal or .git folder or a folder .defignore lists, in any letter case, makes build, watch, setup-debug and scene-types fail with a message naming the setting and write nothing; move it to a folder such as out. A source inside outDir, which tsc never type-checks, fails build and watch until you move it out (Build).
  • A source under a linked folder needs an outDir, and a link leading out of the repository needs link-roots. A project with no outDir whose include folder, or a folder under it, is a symbolic link fails the build, naming the link, and so does a link that include reaches whose target is outside the repository (the project itself when no .git sits at or above it) and every link-roots folder (Linked source folders).

Added

  • @defold-typescript/types/hsm, @defold-typescript/types/ecs and their sub-modules run under bun test, so a machine or a world can be unit-tested with a plain import and no Defold engine. See State machines and Entity systems.
  • build and watch compile sources behind a symbolic link an include pattern can reach, as if they sat at the link's path, when the link leads inside the repository or a folder listed in package.json "defold-typescript"."link-roots"; the pattern matches through a link as in a real folder, and one file reached under two paths fails the build, naming both. watch rebuilds and hot-reloads on an edit inside a linked folder at every link path that reaches it, also after the folder holding a link is renamed (Linked source folders).

Fixed

  • build, watch and resolve wrote through a symbolic link at an output, source-map or runtime folder path, at .gitignore or tsconfig.json, or through a folder link such as .defold-types leading out of the project, so a cloned repository could make them create, overwrite or delete files anywhere you can write. They now refuse that write and name the path, the link and where the link points (Build).
  • watch skipped edits to a source that build compiled when its include pattern started with ./ or held a character class or brace list, such as ./src/**/*.ts, src/**/[su]*.ts or src/{game,ui}/**/*.ts, and setup-debug read those patterns the same wrong way. Both now match include as build does (Watch).
  • On macOS and Linux, a backslash in a tsconfig.json outDir named one folder (out\lua) while the debug launcher looked in out/lua. It now separates folders as on Windows, so delete any leftover out\lua folder (Build).
  • build and watch listed every output in written and the wrote N files line, even one whose bytes had not changed, and watch --hot-reload reloaded the game after a rebuild that changed nothing. They now list only files the build created or changed, and watch --hot-reload reloads only after a successful rebuild that changed a file, counting files an earlier failed rebuild wrote (Hot reload).
  • setup-debug and scene-types ignored an invalid package.json "defold-typescript"."runtime-dir": setup-debug wired the project for the src/ default layout and scene-types wrote a declaration with no script links. Both now fail with the message build gives and write nothing (Build).
  • onMessage and the socket type aliases such as socket.TCPOptions type-checked in build but not under tsc or in the editor: on every Defold target a project's tsc reported Cannot find name 'onMessage' and found no TCPOptions in the socket namespace. Both now resolve in tsc and the editor as they do in build (Routing many messages).
  • build and watch checked every source against the editor and runtime surfaces merged, so a game script calling zip.pack or editor.command built clean while an editor script calling image.load_file or http.server.response failed. Each side is now checked as tsc checks it: an editor script and every helper it imports, directly or through a re-export, against the editor surface plus the bundled hsm and ecs libraries, your own .d.ts files and the Lua libraries resolve installs, but no native extension, and every other source against the runtime one (Editor scripts).
  • sys.save, sys.serialize, json.encode, the properties of factory.create and collectionfactory.create, the value of editor.tx.add, editor and native extension option tables, and library parameters typed as a table of any value rejected a value typed by an interface. On every Defold target these slots now take a PlainTable, which accepts an interface value as well as an object literal or a type alias, while engine values such as Vector3, Hash and Url, functions, coroutine threads and Lua userdata such as file handles are rejected.
  • A scaffolded project fell short of a clean setup in three places; init writes the fixes and upgrade adds them to an existing project:
    • Docs paths: the managed AGENTS.md pointed at docs missing under Bun's isolated installs, so the scaffold now lists @defold-typescript/docs in its dev dependencies, pinned to the CLI's version.
    • .gitignore: generated .ts.editor_script files and .lua.map files outside component output reached version control; the managed rules now ignore both.
    • biome check: a new project reported a schema-version notice and a useBiomeIgnoreFolder warning. The scaffold now pins Biome exactly to 2.6.7, the version its biome.json schema names, and ignores .defold-types the way Biome 2.2+ expects; upgrade moves an older exact pin together with the schema naming it, and keeps any other Biome version or schema you chose.

v0.62.0 - 2026-11-10

Summary:

  • Defold 1.14.1 is the default API target (what changed), with recorder typed.
  • start_record and stop_record lose their message types; recorder replaces them.

Breaking

  • The built-in message types no longer declare start_record or stop_record, which Defold 1.14.1 removes in favor of recorder.start and recorder.stop. A project pinned to 1.14.0 or older that still posts them does so through the untyped msg.post arm.

Improved

v0.61.1 - 2026-11-10

Summary:

Fixed

  • resolve treated the lldebugger dependency setup-debug adds as a library nobody types: it listed it as asset-only, skipped and named it in the notice to declare its modules in src/types/, though setup-debug already declares the one module a project requires from it. resolve now lists it as lldebugger.debug <- <url> (debugger, declared by setup-debug) and leaves it out of the notice, which still names every other untyped dependency (A library nobody types); --json leaves it out of notices too.
  • A warning about a dependency resolve had not materialized did not name the fix: the reason build, watch and scene-types print for it, and for a materialized dependency game.project no longer declares, now ends with run `defold-typescript resolve` (What it does); --json carries the same string in warnings.

v0.61.0 - 2026-11-10

Summary:

Breaking

  • Library data names each library by its lowercase host/owner/repo (Library data), the name lockfile pins, the library commands' folders, the --json source of a resolve match and each library page address (/api/<host>/<owner>/<repo>/<namespace>) use; a pin an earlier CLI recorded under a bare repo name is pinned again at the newest data. A dependency on a host no library's repository is on, such as a company git server or an IP address, matches no library data (Vendored library types).

Improved

  • A dependency matches the library holding its exact host/owner/repo, else the one library sharing its repo name, so a fork on any host a library is on keeps its upstream's types and library status with a notice that they may not fit, and a repo name two libraries share types the dependency with neither, with a notice (Vendored library types). resolve --update=<name>, the library commands and export-types take any trailing part of a library's name (monarch, britzl/monarch, github.com/britzl/monarch), and export-types also a dependency URL.
  • A library's library.json can set minCli, the first CLI release that reads it: an older CLI reads no data for that library, so resolve types it from the dependency's own archive and the library commands leave it out (library).
  • resolve adds one notice naming every dependency that shares Lua nothing types, linking a new guide section that shows how to declare its modules in src/types/<library>.d.ts and how to share them upstream (A library nobody types).
  • init and upgrade scaffold four more mise tasks (Opinionated mise.toml): defold-typescript:typecheck runs the project's tsc --noEmit, defold-typescript:scene-types runs scene-types, defold-typescript:bob-run runs build then bob run, and defold-typescript:sync-target runs set-target --detected.

Fixed

  • library add refuses a repository URL whose host, owner or repo holds anything but a-z, 0-9, ., _ and -, before it downloads, so it writes only inside the data folder: on Windows a backslash in the repo could write outside it (library).
  • On a phone, opening a link to a heading in the guide, the API reference or the library reference shows the heading below the top bar instead of behind it.

v0.60.0 - 2026-11-09

Summary:

Breaking

  • Every page on the library docs lives at an address named by its library's repo (Library page addresses): an API page at /api/<owner>/<repo>/<namespace> (/api/defold/extension-spine/gui, /api/insality/druid/druid) and an untyped library at /libraries/<owner>/<repo>, all lowercase. The flat /api/<name> addresses are gone, so links and bookmarks to them need the new form.
  • proto declares only its own API: proto.Lexer, proto.Parser, proto.toplevel, proto.msg_body and proto.svr_body, internal types of its bundled protobuf compiler, are gone from its declarations and API page. proto.init, proto.encode, proto.decode and its other functions are unchanged.
  • Editor scripts import defineEditorScript, defineEditorCommand, EditorCommand and EditorScriptModule only from @defold-typescript/types/editor-script (Editor scripts), which now exports the two types beside the factories. The bare @defold-typescript/types entry exports none of them, so an editor import from it is a compile error; move it to the subpath.

Improved

  • Every druid and decore parameter has a real type where it was an optional unknown: druid.druid_container.remove_container_by_node takes a node, druid.druid_layout.set_node_position takes a boolean is_instant, decore.system_bus_event.onAddToWorld takes a world, and druid's internal scroll, drag and container methods take numbers, hashes, actions and touches.
  • A curated gameanalytics module types GameAnalytics/GA-SDK-DEFOLD tag 4.2.6 (Curated native extensions): each event function takes a table with its required fields and only the enum spellings the extension accepts, and the remote-config getters return strings and a boolean. Its library page has you install from the repo's tags, naming the 4.2.6 tag archive, since the repo publishes no releases.
  • mpeg.gui_video types the GUI video player of Morgerion/defold-mpeg tag 1.2.0: mpeg.gui_video.init takes a node, a video_resource or video_data, and the playback and sound options, and mpeg.gui_video.update, mpeg.gui_video.final and mpeg.gui_video.is_finished take the player's field.
  • The .script_api namespaces of an Asset Portal library typed here have library pages of their own beside its module's: defsave_ext for subsoap/defsave and mpeg for Morgerion/defold-mpeg.

Fixed

  • resolve declares a .script_api argument named in brackets ([options]) optional (The generated surface), not as a required arg0, and when a required argument follows it also declares the call without it, so open_file(callback) and open_file(options, callback) both compile.
  • resolve writes the .script_api namespaces a typed Lua library's archive documents beside its module (Vendored library types): subsoap/defsave gets defsave_ext and thejustinwalsh/defold-zzfx gets zzfx_ext in .defold-types/extensions/, beside their module types, and resolve --json lists them in that dependency's namespaces.
  • Library docs pages match the code you write and the archive you install:
    • Member names link, tooltip and search as you write them on the pages for Spine's gui and resource, extension-camera, extension-proto, the Firebase extensions, defold-rng and defold-random: gui.new_spine_node is found as written, not as spine.gui.gui.new_spine_node. A name two libraries share links only on its own library's page.
    • Signatures put no ? before a required argument: such an argument reads T | undefined, as in defos.set_window_size, fusion.spawn and the wavedash, playables, poki_sdk and videoplayer pages, and the browser_io page lists each call with and without its options.
    • Install steps for a repo with no stable release name its pinned tag or commit archive, not its releases page: log, tweener, event, dicebag, defmath, ink and eleven other library pages.

v0.59.0 - 2026-11-07

Summary:

  • hsm/builder writes a machine as calls, and view glows the call that fired.

Improved

  • Write a machine as statements: buildMachine from @defold-typescript/types/hsm/builder takes a skeleton of the machine's states, checked as a config is, and statements such as m.state("/off").on("TOGGLE").to("/on"), after, every, always, enter and exit add its behavior, with every path and event checked at compile time. build() hands the result to defineMachine, so the key, hot reload and view work as for a config, with each fired rule glowing on the call that made it; it throws, naming the state, on a rule left without its ending.

v0.58.0 - 2026-11-06

Summary:

Breaking

  • hsm-view is renamed view: run defold-typescript view <file> [name], where [name] picks every machine and world of that name. Its --json line reads "command":"view" and adds the picked world.

Improved

  • The ecs Entity Component System ships with the toolchain: import @defold-typescript/types/ecs, and build and watch write its tiny-ecs port to ecs/index.lua in the runtime folder, MIT license header kept and listed in the CLI's THIRD_PARTY_NOTICES.md, each file written only for projects that import it for values. requireAll, requireAny, rejectAll and rejectAny throw on a token that is neither a component name nor a filter, undefined included.
    • String filters: filter("a&!(b|c)") builds a filter from a tiny-ecs pattern, and a misspelled component in a literal pattern fails to compile. A pattern outside tiny-ecs's documented syntax throws, and tryFilter returns the error instead.
    • Hot reload: system, processingSystem, sortedSystem and sortedProcessingSystem take an optional key. When watch --hot-reload or reload runs the edited module again, a keyed factory puts the new definition into the system it built first, and the world keeps running that system with its entities.
    • ecs and hsm together: import @defold-typescript/types/ecs/hsm to make one table both an entity and an hsm machine's ctx, whose member, join and leave state hooks change which systems hold it while tickMachines updates the machines.
    • Debug a world: inspect from @defold-typescript/types/ecs/debug logs each entity a system gains or loses and each onModify call, keeps logging across a keyed reload, and draws each system's entity count over a game object; in a release build it does nothing.
    • Editor hovers: every export of each module, and every system field and callback, shows a one-line summary, its parameters and return, and an example that compiles; the Reference tables quote the same summaries.
    • Entity systems, one system at a time: a hands-on tutorial grows one night garden of fireflies lesson by lesson, until it uses every export of the three ecs modules. Each change is a diff that compiles, and each lesson shows the console its code prints under the real ecs.
    • The AGENTS.md block that init, upgrade and init-agents write lists hsm and ecs with their import paths and guide pages.
  • view runs a file's machines, script and ecs worlds on one page and one clock:
    • Worlds tab: lists the picked world's systems with their entity counts and timings, opens each one's entities as read-only trees, and links each system to its definition in the code and back. The page opens on it unless [name] picks a machine or the file creates no world, and the log notes each entity that joins or leaves a system.
    • Script lifecycle: a defineScript script's init runs once, and each frame calls its update (or each world's) before the machine's. A reload keeps self and the worlds and calls on_reload.
    • One clock: t and the frame count are the run's time, which Start leaves running, and Restart reruns the files and init from t 0.
    • Follow an instance: the bar's instance dropdown, or an entity's link on the Worlds tab, shows a machine instance the run started in place of the simulated one, its states tinted as the run moves it.
    • Simulated engine values: Lua's math (the same numbers on every start), os.clock, vmath.vector3, vmath.vector4, factory.create, msg.url, go.get_position, go.get_world_position, sys.get_engine_info and sys.get_config_string return simulated values instead of undefined, and ecs filters reject a bad token as they do in a game.

Fixed

  • A script callback named like a module-level binding never ran: a script that imported or declared update, init, on_message or another callback's name at the top level built cleanly, but the engine never called that callback. It now runs, and its body still reaches the binding of the same name.

v0.57.0 - 2026-11-04

Summary:

Improved

  • Forked library types carry the library's own docs: resolve prints each member the library documents with its doc summary and the parameter and return docs for the signature the fork declares, unless a hand-written fork's own comment is pinned to that exact text with @upstreamDoc, so your editor shows on hover what the member's library API page shows. library check names each fork comment that prints the library's doc instead, with the pin that would keep it, and does not fail for it.

v0.56.0 - 2026-11-03

Summary:

  • Library types update without a CLI release, each library pinned until resolve --update[=<name>].
  • Library status says whether each library's commit was reviewed, and library update moves each library to its newest upstream commit, naming what the move did to its members.
  • defold-typescript.lock holds what resolve records; commit it, since resolve --frozen needs it to check the archives bob build will read.
  • resolve --pin-urls moves branch and tag URLs in game.project to commits, and resolve warns about each branch URL.
  • Library API pages moved to their own site, with no redirects.

Breaking

  • resolve fetches library data itself: library types, and the index notes on curated extensions, come from the library data repo and update without a CLI release, and @defold-typescript/library-types is no longer published. resolve and watch pin each library you use at its own commit, so adding or moving one leaves the others' types alone, a notice names each library whose newer data changes more than its recorded reviews, and resolve --update[=<name>] moves what you ask for; export-types reads the newest data.
  • Pins moved to defold-typescript.lock: resolve keeps its records in this committed file instead of package.json, each dependency's entry holding its commit and a hash of the files a game can use, so changed files under an unchanged commit count as drift, which resolve --update accepts. Run resolve and commit the file: resolve --frozen fails without it and when a declared dependency has no entry, and any resolve fails on a lockfile that does not parse.
  • resolve --frozen checks what the build reads: once .internal/lib/dependencies.json exists, it reads only that folder and fails, naming the URL, when the folder does not hold the one archive listed for a dependency, instead of downloading. Run bob resolve, resolve --frozen and bob build in that order to stop a CI build whose libraries differ from your lockfile; see Dependency safety.
  • Library API pages moved: library pages and the Libraries index are on the library docs site, with no redirect from their old /api/<library> and /libraries URLs, and this site's search no longer finds them. Their links to an engine member open this reference at that member, and the Libraries tab opens there in a new tab, marked as an external link.

Improved

  • library update follows upstream: it records each new commit, from the tags or default branch follows names in library.json, whose hashes a review already holds, and moves the library to the newest that differs by re-copying its upstream files and never its forks, failing a library whose new commit no longer holds a file it reads with its folder untouched. Against the review that lists the pinned commit, it reports whether the move kept every member, only added some or changed others, naming them, and reads changed when no single review lists that commit.
  • resolve --pin-urls pins dependency URLs to commits: it rewrites each GitHub branch or tag URL in game.project to the commit its archive names, never over a dependency saved during the run, and resolve --update then follows the original ref inside that repo. resolve and watch warn about each branch URL, and --json reports each dependency's kind of URL as ref.
  • Releases check the library data they publish: a release publishes only after library check passes with that release's CLI on the library data from the same commit, and only once the library data repo serves exactly that data. A nightly run checks that data with every published CLI that reads it, so data a published CLI fails on is reported.
  • Library docs update on every data merge: the library docs site rebuilds with each library data merge rather than each toolchain release. The guides for adding a library and refreshing its pin are there too, and the library add notes link to them.
  • resolve reports each library's status against what library data reviewed: resolve --json carries it as libraryStatus and the plain report names every library that is not exact, from API, doc and source hashes that library add and library review --data <dir> record. A failed download fails that library's review with its record untouched, even with a cached copy.

Fixed

  • Doc comments and API pages keep upstream text that only looks like a tag: declarations lost everything from a < to the next >, so the random library's probability doc read Values = 1 are always true. Text such as Values <= 0 and particlefx.EMITTER_STATE_<STATE> now comes through whole.
  • A game.project with CRLF line endings keeps its dependencies: its dependencies#N lines read as absent, so resolve and watch removed the project's dependency types and the scene walk saw no dependencies.

v0.55.0 - 2026-10-31

Summary:

  • Dependency types follow the archives Defold fetched, and their pins name a commit; a plain resolve replaces an old sha256: pin.
  • Library types are printed from the library version the game depends on, and resolve --library-data reads library data from a local directory.
  • library add and library check start a library's data folder from its archive URL, check it against this CLI's engine types and its coverage floors, and can write the API models the docs site renders.
  • Script properties compute their defaults at build time and register in the key order the source shows.
  • The docs site documents the npm version.

Breaking

  • Dependency pins name a commit: resolve pins each dependency as commit:<sha>, read from a GitHub archive's zip comment, or else as files-sha256:<hex> over the files its include_dirs share, so a pin moves only when the code a game uses does. A plain resolve replaces a sha256: zip-byte pin in package.json, and resolve --frozen fails on one until it has; see Pinning extension versions.

Improved

  • Library types follow the library version the game uses: resolve prints a matched library's declarations from the archive the project depends on, and prints the version library data pins with a warning when that archive cannot be printed; a library typed by a hand-written fork keeps its fork. See Vendored library types.
  • Library data from a local directory: resolve --library-data <dir> reads library data from <dir> instead of the installed package. Library data sits in folders named by the first CLI version that reads them, and a CLI reads the highest one at or below its own version; see Flags.
  • Add and check library data: library add <url> --data <dir> starts a library's folder from its archive URL, with its pin and, when its .script_api or annotated Lua can generate a module, a starting recipe and the upstream files it reads, and refuses a folder that already exists, even one created during the download, without changing it. library check --data <dir> runs the reader's checks, prints every module, compiles the declarations and usage examples against this CLI's own engine types and holds each module to its floor in library.json, a module with no floor or below it being a problem, exiting 1 on any problem, and --api-doc-out <dir> then writes each library's API model; see library.
  • Script properties are computed at build time: a defineScript properties default Defold's build cannot read as written, a spread, shorthand or const-keyed member, and a properties value that is not an object literal are evaluated in a sandbox and register one literal go.property per name, in JavaScript's key order as read through consts and their spreads, imported ones included. A default that needs an engine API, randomness or a file, whose value is not a property type, or whose key order the source does not show, such as two names from a function result, fails the build with a diagnostic naming the cause, and the text-property version gate covers the strings a spread brings in.

Fixed

  • Dependency types stayed at the first download: resolve served the copy it first cached of a moving archive such as master.zip, even after Defold's Fetch Libraries moved the game to newer code, and watch re-resolved only on a game.project save. It now reads the archive Defold fetched into .internal/lib/ when its commit matches, else revalidates its own cache by ETag and uses it offline with a warning, and watch re-resolves after each Fetch Libraries; see Cache location.
  • Some libraries shared no scene sources: a library whose include_dirs named a nested or slash-wrapped directory such as /monarch/transitions/, separated its directories with whitespace, or sat in a game.project with CRLF line endings gave scene types nothing to address. Each form is read, and every file beneath a declared directory is shared; see Dependency scene sources.
  • The docs site described unreleased changes: it was published on every push to main, so a guide or API reference page could document behavior the version on npm lacks. It is now published once per release and documents that release.
  • Script properties dropped silently: a spread, shorthand, method, accessor or variable-keyed member of defineScript properties, or a whole object wrapped in as or satisfies, registered no go.property while self still typed it, and a default Defold's build cannot read, such as a module const, failed only in Defold's build. Each member now registers or fails the build, a literal key such as ["a-b"] or 0x10 registers under its JavaScript name, and an infinite number registers as 1e999.

v0.54.0 - 2026-10-28

Summary:

Breaking

  • A .script_api callback parameter is typed from its documented arguments in the .defold-types/extensions/<namespace>.d.ts that resolve writes: iap.set_listener takes (self: unknown, transaction: { ident: string; state: string; ... }, error: Record<string | number, unknown>) => void where it took (...args: unknown[]) => unknown, so a listener declared with other argument types or a non-void return no longer type-checks. A callback whose doc lists no arguments keeps (...args: unknown[]) => unknown.
  • king8fisher/defold-pixels is typed by the module its archive ships in types/ in place of its .script_api (Types a library ships): use it through import * as pixels from "pixels" where the global pixels was typed, and every buffer argument takes a PixelsBufferInfo where it took any table. A project that copied upstream's types/ files deletes the copies, which otherwise redeclare their names (TS2451, TS2300).
  • Native extensions are modules a script imports: write import * as share from "share" where the bare global was typed. A bare use fails with Cannot find name, and a type named through the namespace, such as share.FileOptions, needs the import too:
    • .script_api namespaces that resolve writes, shared ones such as firebase and dotted ones such as rive.cmd (import * as cmd from "rive.cmd") included. A doc that adds members to an engine namespace, such as Spine's gui, stays global.
    • The curated daabbcc, share, uuid4 and tile_raycast natives (Curated native extensions), so a call such as uuid4.generate goes through the import.

Improved

  • resolve installs the declarations a dependency ships in a root types/ folder (Types a library ships) unchanged under .defold-types/extensions/shipped/<repo>/, where they keep their names and may reference each other by relative path, ahead of a vendored library match, a curated native namespace or its .script_api, once they compile against @defold-typescript/types with each dependency checked on its own; files that add global names are left out when one file declares a module, and files that do not compile fall back with a warning. --json reports typeSurface: "shipped", and library authors can follow Shipping types with a library.
  • export-types writes a library's curated types into a types/ folder its maintainer can ship (Starting from the curated types): bunx @defold-typescript/cli export-types <library> [path] copies the declarations resolve installs for the library today, unchanged, and writes nothing unless the types/ folder the file system will hold, files already there included, would install with every exported file and pass the check resolve runs on shipped types. Where the file system ignores letter case, an existing file whose name differs only in case is the one an exported file overwrites, and it keeps its name.
  • A native extension typed in module form builds in Defold with @globalTable (Module-form native extensions): tagging the ambient declare module with /** @globalTable [name] */ makes every import of it — namespace, named, re-export or dynamic — compile to a local alias reading the extension's runtime global through _G, so no project local shadows it, the built Lua carries no require of a module no file provides, and the Defold editor and bob load it. A tag naming an invalid Lua global fails the build with the file and line.
  • resolve extension declarations carry the whole documented surface: the namespace's constants, including those one sub-table deep (iap.PROVIDER_ID_GOOGLE, push.NOTIFICATION_BADGE), each branded as the string or number its doc declares (firebase.analytics.EVENT_ADIMPRESSION is a string brand), a function returning a documented constant typed as that constant union, a parameter flagged optional: true emitted optional, and a table parameter typed from its documented fields. A .script_api slot typed enum is read as a constant-valued slot, so webview.create's callback type argument is the union of the webview.CALLBACK_RESULT_* constants.
  • The facebook, playables and poki_sdk Libraries pages show the parameter types their .script_api spells as YAML lists ([string, nil]), which previously rendered as untyped.
  • Library pages define the types their signatures name: a union, function-type or other non-object alias such as monarch.monarch.ScreenId or richtext.richtext.Alignment shows its definition (type ScreenId = Hash | string) and the signatures taking it link to it, and an interface named only by another interface's field, such as yagames.MultiplayerSessionEvent or node_repeat.RepeatFrame, gets its own entry. An interface shows the interface it extends, such as platypus.PlatypusInstance, and its call signature when it is callable, such as defcon.CommandCallback.
  • Libraries lists the Defold Asset Portal's libraries under their GitHub owners: one that ships a .script_api gets a reference page per doc, such as defos, and one that ships no Lua API, such as shaders, materials and editor scripts, gets an icon-marked page, such as defold-sharp-sprite. Each page gives the dependency step for its pin and links the library's Asset Portal entry.
  • A Defold extension or Asset Portal library page pinned to a release or tag names the Defold version current when it was cut (Browsing Defold's own extensions): iap reads released while Defold 1.13.1 was current beside its pin, as do portal pages such as astar and defold-sharp-sprite, a hint at the pin's age rather than a compatibility promise.
  • More Asset Portal libraries are typed, from their LuaLS annotations or, for a library that ships none, by declarations maintained here: declare the dependency and resolve writes its typed module. quest and token import event from Insality/defold-event, so a project using either one declares defold-event beside it.
    • detiled (Insality/detiled, tag 3) — detiled.parse returns a Tiled map's layers and map params, which detiled.cell_to_pos and detiled.pos_to_cell take to convert between cells and positions.
    • token (Insality/defold-token, tag 9) — token.container returns a container whose token.token_container.get returns a number and whose change events take a callback alone, as they do in Lua, and token.on_token_change, token.on_token_visual_change and token.on_token_restore_change are exported as module-wide events.
    • quest (Insality/defold-quest, tag 3) — quest.event reports a game event to the active quests, quest.start_quest returns whether the quest started, and the quest.on_quest_event queue and the quest.is_can_start, quest.is_can_complete and quest.is_can_event checks are exported for subscribing.
    • pigeon (paweljarosz/pigeon, tag v1.5) — pigeon.send_to takes any receiver msg.post takes (a Url, a URL string or a hash id), and pigeon.send posts to every subscriber pigeon.subscribe registers.
    • live_unbundler (HGPoint/defold_live_unbundler, tag 2.3) — the module's unannotated constants are exported: the res_mode values such as live_unbundler.RES_BOTH that live_unbundler.init takes, the Hash message ids such as live_unbundler.MSG_ALL_LOADED its listeners receive, and the log levels live_unbundler.set_log_function passes.
    • ads_wrapper (potatojam/defold-ads-wrapper, tag 1.5.1) — ads_wrapper.ads_wrapper.register_network returns a network's id or nil and accepts the test networks, such as ads_wrapper.ads_networks.test.network1, and twelve ad-SDK network modules, such as ads_wrapper.ads_networks.vk, ads_wrapper.ads_networks.applovin_max and ads_wrapper.ads_networks.admob, whose declarations are maintained here, each typed with its own functions and constants. The ads_wrapper.events hashes, the ads_wrapper.platform checks and the ads_wrapper.queue functions are typed too, where ads_wrapper.queue.add takes a function called as (network, callback, params).
    • fake_real_glass (paweljarosz/defold-fake-real-glass, tag v1.1) — the defold-glass render module: fake_real_glass.create takes a probe mode typed as its three values, such as fake_real_glass.PROBE_MODE_EVERY_FRAME, and the fake_real_glass.MSG_SET_PROBE_POSITION and fake_real_glass.MSG_SET_PROBE_SETTINGS ids that fake_real_glass.on_message handles are exported.
    • hyper_trails (indiesoftby/defold-hyper-trails, tag 1.4.2) — import * as trail_maker from "hyper_trails.trail_maker", whose functions, such as hyper_trails.init_vars, take the script's self or a plain options table.
    • pixelart.scripts.pixelart (selimanac/defold-pixelart-shader, commit 8db334d) — pixelart.scripts.pixelart.init requires the pixel size and edge coefficients and takes optional light and shadow settings, and a render script passes its self to pixelart.scripts.pixelart_render.init and the camera frustum, view, projection, window size and clear buffers to pixelart.scripts.pixelart_render.update.
    • outline (selimanac/defold-3D-outline-shader, commit 07c2eee) — import * as outline from "outline-shader.outline": a render script passes its self to outline.init and its predicates and a { frustum } table to outline.update, and a game script picks a stencil or inverted-hull outline with outline.set and outline.type.
    • sentinel (indiesoftby/defold-sentinel, tag 1.3.1, maintained here) — sentinel.init requires a dsn, sends its user table to Sentry as given, nested tables included, and takes on_soft_crash and on_hard_crash callbacks that must return a string or a number, which the library writes into a log line. sentinel.capture_message takes one of Sentry's five levels.
    • GamePush (megalanthus/defold-gamepush, tag v1.4.1, maintained here) — import * as gamepush from "gamepush.gamepush" reaches all 32 SDK modules through fields such as gamepush.player and gamepush.platform, each also importable by its own id (import * as channels from "gamepush.core.channels"), and every module delivers its events to typed handler slots on its callbacks table, such as gamepush.callbacks and gamepush.core.channels.callbacks. A table or argument the Lua rejects when missing is required, as for gamepush.init and gamepush.core.player.enable_auto_sync, and the Lua's constants keep their literal values, such as gamepush.languages and gamepush.core.platform.YANDEX.
    • colyseus (colyseus/colyseus-defold, tag 0.18.1, maintained here) — import * as Colyseus from "colyseus.sdk" gives colyseus.Client, whose matchmaking calls take their options optionally and call back with either the error or the joined room, colyseus.callbacks, whose schema callbacks take the value type their callback declares, and colyseus.protocol with its literal codes. A room's on accepts only the six events it emits, each listener typed for its event.
    • printer (Insality/defold-printer, tag 1.2.2, maintained here) — printer.new returns a printer.Printer that prints dialog text letter by letter in a gui scene, and printer.print returns false when text was still printing and the new text did not start. Styles passed to printer.add_styles carry only the fields they change, copied over the style in effect or, for a source style, over the default style, except a style named default, which replaces the default style and must carry its core fields.
    • ink (abadonna/defold-ink, commit 5e871c4, maintained here) — ink.create parses a compiled ink story into an ink.Story, whose ink.Story.continue and ink.Story.jump return the paragraphs written and the answers to choose from, and whose ink.Story.get_state result restores the story through ink.Story.restore.
    • light_and_shadows (Dragosha/defold-light-and-shadows, tag v0.9.1, maintained here) — a render script passes its self to light_and_shadows.light_and_shadows.init and light_and_shadows.light_and_shadows.update, and light_and_shadows.light_and_shadows.dof requires blur_resolution in its options table, which the Lua copies with no fallback. light_and_shadows.light and light_and_shadows.constants type the light sources, camera position and shader constants a game script sets.
    • flow (Pause-Games/flow, tag 1.0.0) — requiring flow/flow gives the typed flow.flow.init, flow.flow.update, flow.flow.on_input and flow.flow.on_message lifecycle facade with flow.flow.ui, flow.flow.log, flow.flow.color, flow.flow.bottom_sheet and flow.flow.nav, whose replace takes a transition string and which carries the navigation message ids such as PUSH, on_message and its handle_message alias both directly and under messages; its page documents the component constructors in flow.flow.FlowComponents, the Markdown parse and viewer helpers in flow.flow.FlowMarkdownComponent and the nav.runtime methods in flow.flow.FlowRuntimeFacade. The directly importable modules include flow.bottom_sheet, which type-checks its props, and flow.color, whose pages document calling the module itself (flow.bottom_sheet.FlowBottomSheetModule, flow.color.FlowColorModule), the chainable flow.flex.Node.new, and the shared element, style, screen and navigation types in flow.types.
    • pointer_lock (indiesoftby/defold-pointer-lock, tag 2.1.0, maintained here) — import * as pointer from "pointer_lock.pointer" gives pointer_lock.transform_input, which returns the action id and the on_input action with x and y moved to the virtual cursor and its other fields kept, and returns no action id unless the pointer is locked and the cursor is visible. pointer_lock.locked reads the lock state that pointer_lock/pointer_lock.script keeps.
    • operator (astrochili/defold-operator, tag 1.5.3, maintained here) — operator.operator.get_active_operator returns the active operator's url or undefined, and the settings fields, such as operator.operator.flight_look_easing, are assigned through a cast. operator.bezier builds a curve with operator.bezier.new from vector points, or from number points with a required length function, and operator.bezier.Bezier.uniform_position returns the point that fraction of the way along it.
    • defarmy (dev-masih/defarmy, tag v1, maintained here) — import * as defarmy from "defarmy.defarmy" gives defarmy.army_create and defarmy.army_update_pattern, which take one of the defarmy.PATTERN hashes and, for the CUSTOMIZED one, a function returning how many soldiers stand in each row. defarmy.soldier_move returns a soldier's next position and rotation, both undefined once the soldier is removed.
    • defgraph (dev-masih/defgraph, tag V4.1, maintained here) — import * as defgraph from "defgraph.defgraph" builds a map with defgraph.map_add_node and defgraph.map_add_route, and defgraph.move_player returns the defgraph.MoveData to keep beside a defgraph.MoveResult whose rotation is undefined unless defgraph.move_initialize was given an initial face vector. Every setting defgraph.map_set_properties and defgraph.debug_set_properties take is optional, a nil keeping its current value.
    • def_behavior_tree (s-kania/def-behavior-tree, tag 1.0.0, maintained here) — import * as BehaviorTree from "def_behavior_tree.behavior_tree" gives def_behavior_tree.registerTemplates, whose templates take only their own node types and name a node by string only beside a NODES table, and def_behavior_tree.new, which types the tree and its task callbacks by the payload it is given, undefined when there is none. def_behavior_tree.BehaviorTree.run starts the tree at an optional node id and does nothing while it is running, and def_behavior_tree.BehaviorTree.activeNode is undefined until the first run.
    • dissolve_fx (indiesoftby/defold-dissolve-fx, tag 1.2.0, maintained here) — import * as dissolve_fx from "dissolve_fx.dissolve_fx" gives dissolve_fx.init, which takes an optional stretch or cover scale mode for the noise, and dissolve_fx.find_uvrect, which returns an atlas image's uv rect as four numbers.
    • illumination (astrochili/defold-illumination, tag 1.0.3, maintained here) — illumination.set_light takes a light whose position, color, radius and cutoff are required, or undefined to remove it, and illumination.set_environment takes any of its eight optional fields, its fog type one of illumination.FOG_TYPE_NONE, illumination.FOG_TYPE_LINEAR and illumination.FOG_TYPE_RADIAL. The init and post_update_data_texture functions that only the bundled illumination.script calls are not declared.
    • water (selimanac/defold-stylized-water-shader, commit bdcc1d8, maintained here) — import * as water from "water.water" gives water.init, which requires the camera, sun and water objects and the time speed, and getters such as water.get_wave1 that return their values as separate numbers. A render script calls water.render_init on the state its init returns, after which self.predicates holds the water predicate water.render_update needs beside model, and water.set_edge_foam_type takes 0 or 1.
    • defold-wrap (baochungit/defold-wrap, tag 1.1.0, maintained here) — import * as wrap from "wrap.wrap" gives wrap.wrap.node and wrap.wrap.go, which wrap a GUI node or game object as a wrap.node or wrap.go whose gui.* or go.* setters chain, or a list of them as a wrap.node_list or wrap.go_list, and wrap.wrap.gui_applet, whose wrap.gui_applet shows wrap.gui_scene scenes made of wrap.gui_object objects. Each hook sees its scene or object as this, in a subclass from wrap.gui_scene.extend or wrap.gui_object.extend, which types its fields and an object's props and settings, or in a plain table of hooks and fields, which may not set the __name, new or __index a class carries.
    • minit (Minit-Games/minit-defold, tag v1.17.0, maintained here) — import * as minit from "minit.minit" gives minit.report_result, which takes a number or string score with optional flavor_text, delay and user_data, and minit.on_viewable_change, which returns the function that unsubscribes. minit.get_user_data returns undefined when nothing is stored, and outside an HTML5 build every call prints or returns a fixed result.
    • asobi (widgrensit/asobi-defold, tag v1.18.1, maintained here) — import * as asobi from "asobi.client" gives asobi.client.create, whose client carries its tokens, an asobi.realtime connection whose asobi.realtime.Realtime.on accepts only the 45 events it fires with each handler typed for its event, and the asobi.http transport and 15 REST modules such as asobi.api.auth, whose calls take the client first and call back with the decoded body or an asobi.http.HttpError. asobi.client.quick_start requires a host, and asobi.api.auth.guest_device signs a guest in with the device id and secret asobi.device.load_or_create generates and saves on first run.
  • yagames declares the readiness flags its module table opens with: yagames.ysdk_ready, yagames.payments_ready and yagames.player_ready read true once yagames.init, yagames.payments_init and yagames.player_init succeed, and yagames.banner_ready stays false.
  • Fourteen more native extensions are typed by curated modules (Curated native extensions), each imported by its namespace (import * as png from "png"), so a project depending on any of them gets types where resolve wrote none:
    • def_windward_jps (s-kania/def-windward-jps, tag v1.1.0) — def_windward_jps.create_grid returns a grid whose def_windward_jps.Grid.find_path and def_windward_jps.Grid.is_walkable take 1-based def_windward_jps.Point cells.
    • box2d (d954mas/defold-box2d, tag 1.0.3) — box2d.NewWorld returns a world whose bodies, fixtures, shapes and joints carry their methods, and box2d.World.CreateJoint accepts only the joint definitions the extension can build and returns the joint type each one names.
    • daabbcc3d (selimanac/defold-daabbcc3d, tag v1.0.6) — daabbcc3d.insert_aabb and daabbcc3d.query_aabb take a Vector3 position with width, height and depth, and daabbcc3d.rebuild_all takes its flag second, where the runtime reads it.
    • wave (selimanac/defold-wave, commit 76ff0c9) — wave.add_gameobject floats a game object on the simulated water, and wave.get_wave1_height and wave.get_wave2_height require the time argument the runtime reads.
    • detour (abadonna/defold-detour, commit 95ce965) — detour.init loads a Recast navmesh whose detour.NavMesh.find_path returns path corners keyed from 0, and detour.NavMesh.create_crowd returns a detour.Crowd that steers agents along it.
    • taptic_engine (MaratGilyazov/def_taptic_engine, tag v1.2) — taptic_engine.impact, taptic_engine.notification and taptic_engine.selection play haptics once taptic_engine.isSupported confirms the device can; the namespace exists on iOS only.
    • gyro (britzl/defold-gyro, tag 1.1.1) — gyro.start takes a required listener the extension calls every frame with the device rotation as a quaternion, on iOS and Android only.
    • fontscale (myopic-design/defold-fontscale, tag v0.1.0) — fontscale.get returns the operating system's font-scale factor on every platform.
    • directories (Lerg/extension-directories, commit 2023870) — directories.path_for_file resolves a file path inside the platform directory one of the five constants names, with both arguments optional, and returns nothing when the directory cannot be resolved.
    • uptime (AGulev/defold-extension-uptime, tag 1.2.0) — uptime.get returns the seconds since the device booted, on iOS, Android, macOS and Windows only.
    • png (britzl/defold-png, tag 1.2.2) — png.encode_rgb and png.encode_rgba turn raw pixels into PNG bytes, and png.decode_rgb and png.decode_rgba decode a valid PNG into a pixel buffer with its width and height, or three nils when the buffer cannot be created; a corrupt PNG may crash the engine. png.info reads a PNG's dimensions, color type and bit depth without decoding it.
    • imp (britzl/defold-imp, tag 1.1.0) — imp.convolution applies a row-major 3x3 kernel to a source buffer and writes the result into a destination buffer; both need a uint8 rgb stream and at least width * height elements, and the extension does not check the element count.
    • openal (Lerg/extension-openal, commit 618292f) — openal.new_source creates an openal.Source from a WAV file loaded with resource.load, or returns nil when it cannot load one, and the source's position, gain, looping and other properties are set in place before openal.Source.play. openal.listener is read-write, openal.doppler_factor and openal.speed_of_sound are set through a local holding the import, and the extension needs Defold's own sound system disabled.
    • ainpc (elefant-ai/player2-ai-npc-defold, commit ecda39f) — ainpc.chat_completion, ainpc.npc_spawn, ainpc.npc_chat and ainpc.npc_kill send requests to the running Player2 desktop app and require both a reply and a failure callback, and ainpc.npc_responses returns the stream id ainpc.stop_npc_responses takes. A string body is accepted only where the extension reads it as one, and the docs note that a game_id reaches only the ainpc.npc_responses request.

Fixed

  • build and watch compile a project using the types resolve installed (build): they load the declarations behind the tsconfig "extensions" and libraries@<cliVersion> entries as type information only, where a curated native call such as uuid4.generate failed with Cannot find name and a vendored library import such as checkpoint.checkpoint with Cannot find module.
  • resolve works from the published packages for a project depending on a native extension, under Node and Bun on macOS, Linux and Windows (resolve), where Node failed to load the types package's TypeScript scripts (a bare C:\ path on Windows, type stripping under node_modules elsewhere) and Bun found none of the fixtures/defold-* documents in the published @defold-typescript/types. Reading an extension archive needs no unzip binary and reads an archive carrying any comment that does not itself embed a zip directory.
  • resolve keeps every dependency's declarations of a namespace they share, writing each to its own .defold-types/extensions/<namespace>.<dependency>.d.ts, numbered when another file already has that name, and printing merged <namespace> from <urls> (--json adds a sharedNamespaces array), where it kept only the last dependency's and a project using several Firebase extensions lost firebase members (resolve). An extension declaring an engine namespace, such as Spine's gui, no longer re-declares gui.Playback and 12 other engine type aliases, which a type check with skipLibCheck: false reported as TS6200 conflicts.
  • resolve keeps both declarations when two namespaces differ only in letter case, such as Foo and foo, writing the second to a numbered file such as .defold-types/extensions/foo-2.d.ts, where on macOS and Windows one replaced the other (resolve).
  • druid, decore and proto methods take every parameter their Lua declares: one the LuaLS annotations leave out is an optional unknown, so druid.druid_layout.set_node_position takes its is_instant flag and proto.Parser.addpath its path, where a call passing them failed with Expected 0 arguments or one fewer.
  • init and upgrade write noEmit: true into tsconfig.json when the project sets none, so a bare tsc no longer writes a .js file beside every .ts source; build output is unchanged (init).

v0.53.0 - 2026-10-20

Summary:

Breaking

Improved

  • API pages file every type under one Types heading, named by its full path on engine pages, and every handle method under Functions. An alias or interface is one row there, such as image.Type, which opens with a Lua badge linking the reference's own image.TYPE to its defold.com entry, while a type with fields, such as go.on_input on go, and a handle's methods, such as the client methods on socket, each get a heading nested inside.
  • druid types follow Insality/druid 1.4.1: druid.druid_button.set_cursor sets one button's hover cursor, and druid.druid_instance.reset_hovers clears every hover in an instance when another GUI covers it; both return their own object, so calls chain.

Fixed

  • go.animate, resource.create_atlas, resource.set_atlas, and resource.get_atlas use the full go.Playback union on every target, including go.PLAYBACK_NONE.
  • An entry script wired by setup-debug builds when it exports runtime values. The unedited managed block no longer fails the companion's order rule at its if, and its gated lldebugger.start() runs before the companion loads; an edited block is still rejected, with an error that says to run defold-typescript setup-debug to restore it.
  • The F5 debug launcher carries a normalized body checksum and stays current through upgrade or init . --force. An unmodified current or legacy launcher is refreshed even after CRLF conversion, a customized launcher is preserved and named in a warning with an explicit reset path, and F5 stops for a missing engine build or warns before running a stale one.
  • upgrade reports the version the project had before the run — its installed @defold-typescript/cli, else its package.json pin — in the summary line and the --json from field, so bunx @defold-typescript/cli@latest upgrade no longer claims "already latest" after moving the project to a newer release. When neither names a version, the line reads none -> <to> and from is left out.
  • upgrade tells distinct prereleases apart — digit-led ones such as 1.3.0-1alpha and 1.3.0-1beta, and very long numeric ones such as 1.3.0-9007199254740992 and 1.3.0-9007199254740993 — so a CLI on the older one hands off to the newer one instead of re-scaffolding from its own templates and calling the project already latest.
  • model.Properties declares all sixteen texture units the engine handles, "texture0" through "texture15", on every pre-baked Defold version, so go.get<model.Properties>()("#model", "texture8") compiles; a surface generated from a reference doc alone keeps "texture0" through "texture7".
  • API reference pages list the complete engine type inventory, with every interface and type alias the declarations define shown in full. This covers the five socket handles and their methods (socket.SocketClient, socket.SocketConnected, socket.SocketMaster, socket.SocketServer, socket.SocketUnconnected), option and result tables such as b2d.Aabb, bullet3d.VersionInfo and sys.SysInfo, and aliases such as gui.Node.
  • shutter and checkpoint point at their new home on Codeberg, where their author moved them after deleting the GitHub repos. Their reference pages and declaration source links lead there, and the adopt step gives the Codeberg archive URL to replace a dead github.com/Klaleus dependency in game.project.

v0.52.0 - 2026-10-17

Summary:

Breaking

Improved

  • gui.get returns each node property's type: "position" reads as a Vector4, "rotation" as a Quaternion, and a sub-key or scalar as a number, so a read needs no cast.
  • Each state machine module is written with a source map to the library's .ts: a debugger frame inside the library opens TypeScript, and watch and reload console lines name that file when a local install keeps it inside the project.
  • bullet3d.collision_object.is_rigid_body narrows its argument to a rigid body, so a checked collision object passes to bullet3d.rigid_body.apply_central_impulse and the other rigid-body functions without a cast.
  • API reference signatures bold only names: each signature heading, overview entry and overload form reads at normal weight with the member name, its parameter names and those of a function-typed parameter, property or return in bold, and the Parameters and Returns lists bold their slot names the same way while their labels and doc text carry no bold.
  • The Box2D world queries take a "v3" type argument on Defold 1.13.2 and later: b2d.world.cast_ray, b2d.world.cast_ray_closest, b2d.world.cast_shape, b2d.world.overlap_aabb and b2d.world.overlap_shape return the v3 hits and shape tables when called as b2d.world.cast_ray<"v3">(…), and the v2 ones with no type argument. The API reference and llms-full.txt list both forms of each query as available from Defold 1.13.2, each with its own return type and description; see Box2D v3 query hits.

Fixed

  • Declarations the engine bindings contradict follow the engine:
    • buffer.get_bytes takes just the buffer and is documented as returning every byte of it; stream_name is optional and ignored.
    • Buffers have buf.length(), which compiles to #buf and returns the element count.
    • go.delete takes any table whose values are ids, so go.delete(ids) deletes everything a collectionfactory.create call spawned.
    • go.get of an array material constant without index returns every element, and the result casts to Vector4[] in one step.
    • gui.clone_tree and gui.get_tree take undefined for the whole scene, but the argument cannot be left out, since a call without it raises; see Passing absence.
    • hash takes a Hash and returns it unchanged, and the API reference and llms-full.txt list both forms for every Defold version.
    • http.request passes its response callback the sender url as a fourth argument.
    • Label and sprite vector properties take one sub-key per component: a Vector3 property (label and sprite scale and size) takes .x to .z and a .xy key that is a Vector3, and a Vector4 property (label color, outline and shadow; sprite slice) takes .x to .w. So go.get<label.properties>()("#label", "color.w") is a number; see Component properties.
    • liveupdate.LIVEUPDATE_NOT_INITIALIZED is declared and is a member of liveupdate.LIVEUPDATE, which liveupdate.add_mount and liveupdate.remove_mount return while live update is disabled.
    • material.get_samplers and compute.get_samplers report a sampler's type as a graphics.TEXTURE_TYPE or one of the values 6 to 10, which a separate sampler or texture binding reports and no constant names.
    • msg.url takes a Hash or a Url as its one argument, and its three-argument form takes undefined for path and fragment as well as socket.
    • render.render_predicate is the Opaque<"render_predicate"> handle render.predicate returns, so a value annotated with it passes to render.draw.
    • Url.socket takes undefined, which clears the socket.
  • llms-full.txt dates each overload of go.get, go.set, go.property, render.render_target and sys.get_config_string by its own availability: their first form exists on every tracked version, so it carries no [through 1.13.1] [signature transition] tag.
  • defineGuiScript and defineRenderScript reject a properties block: Defold builds go.property only in .script files, so the field fails to compile and the transpiler refuses to emit the calls Defold's build would reject. A GUI or render script gets a per-object value from a sibling defineScript, which declares the property and sends its value with msg.post in init.
  • A partly walled project, and a wall that imports a helper from outside it, type-check: each wall checks a helper it imports against its own kind, and a helper no wall imports keeps the full surface; see Kind-neutral helpers.
  • The @defold-typescript/types/render-script entrypoint leaves out the functions that need a game object, which always raise "no instance could be found" in a render script: every function in sprite, factory, collectionfactory, collectionproxy, label, model, particlefx, physics and tilemap, most of go (go.get_position, go.animate, go.property), and part of b2d, bullet3d, resource and sound; see API availability by script kind.
  • run, bob run and the debug launcher launch the native-extension build engine on macOS, where bob writes it to build/<arch>-osx/dmengine, and on every platform they stop with an error, rather than launch the stock engine, when the project has an ext.manifest but no build engine. Refresh an existing launcher by deleting .vscode/defold-debug.ts and running setup-debug.

v0.51.0 - 2026-10-14

Summary:

Breaking

  • Hooks and callbacks match what the engine calls and passes:
    • window.set_listener and collectionproxy.load callbacks receive typed payload structs on Defold 1.13.2 and newer targets, window.event_data and collectionproxy.load_data. A callback that annotates either parameter as a record, or reads a key the engine never sends, stops compiling; drop the annotation or name the struct.
    • defineRenderScript accepts only init, update, on_message and on_reload; a render script's final, fixed_update or late_update, which the engine never calls, stops compiling.
    • model.play_anim's completion callback receives no sender, so a callback declaring a fourth parameter stops compiling.
    • isWindowEvent narrows a non-resize event's data to Record<string, never>, the empty table the engine passes, not undefined.
  • render.render_target checks its table on Defold 1.13.2 and newer targets, in both arities: each buffer needs a format, width and height, and a format constant other than depth or stencil needs a nil check first. To build the table ahead of the call, type it as render.RenderTargetParams, which every pinned target declares, as an open record on older pins.
  • Five engine returns can be undefined, as the engine source shows: factory.create when the spawn fails, tilemap.get_tile, tilemap.get_tile_info and tilemap.get_tiles for an unknown layer (the first two also for a cell out of range), and the second value of collectionproxy.set_collection when the change succeeds. Code that uses the result directly stops compiling; narrow it with !== undefined first.
  • The typed go.set<P>() form rejects keys the engine never writes: model.animation and sprite.texture0 are read-only, so a typed write to either stops compiling.
  • Ray-cast results carry only what the engine sends: physics.raycast results have no request_id, and on Defold 1.12.4 to 1.13.1 targets the result is one hit or a list of hits, as on newer ones; the ray_cast_missed message has no group. Code that reads either field, or indexes the result without an Array.isArray check, stops compiling.
  • Three engine userdata types follow the metatables the engine registers:
    • vmath.vector gives its size through Vector.length, called as v.length(), which compiles to #v; reading v.length as a field raises at runtime and stops compiling.
    • Url.path can be undefined, since a socket-only address such as msg.url("main:") has no path; check it before use.
    • An array constant read back from a constant buffer is a ConstantArray, a 1-based proxy with no length, not an array; assigning an array to it still compiles.

Improved

  • Url fields are writable and Matrix4.mul takes a number, as the engine allows: assign Url.socket, Url.path or Url.fragment a Hash or a string, and scale a matrix with m.mul(2).

  • More returned tables, property reads and callback payloads match what the engine source pushes:

    • graphics.adapter_limits declares max_storage_buffers_per_stage on Defold 1.14.0 targets.
    • sys.interface_info declares family, "ipv4" or "ipv6", absent for any other interface, on Defold 1.13.2 and newer targets.
    • go.get and go.set read and write a Matrix4 property, and go.get reads "position.x" and every other single-component transform key as a number, and "scale.xy" as a Vector3.
    • Component property catalogs declare the keys the engine handles: model.properties gains material and skin, physics.properties gains bullet (Box2D only), mesh.properties gains material and texture0 through texture15, and new factory.properties and collectionfactory.properties declare a read-only prototype.
    • Id tables from collectionfactory.create, gui.get_tree and gui.clone_tree read by path as well as by hash, as in ids.get("/go").
    • on_input touch entries declare all twelve fields as always present, so touch.x is a number with no undefined check.
    • http.request responses declare url, and report_progress events declare bytes_sent.
  • Built-in messages declare what the engine handles and sends: play_sound takes pan and speed, play_animation takes offset and playback_rate, pause_sound and set_pan are declared, collision_response, contact_point_response and trigger_response carry group, and the a and b bodies of contact_point_event, collision_event and trigger_event declare the fields the engine sets.

  • Physics listener events narrow with isPhysicsEvent: on Defold 1.13.2 and newer targets each physics.set_event_listener event carries its type hash, and isPhysicsEvent(event, "collision_event") narrows it to that one event.

Fixed

  • image.get_astc_header returns its header without undefined: the engine raises on invalid data instead of returning nil.
  • sys.get_sys_info returns device_model, manufacturer, device_ident and user_agent as strings: the engine always sets them, as an empty string where the platform has no value.
  • Built-in message payloads accept what the engine accepts: set_gain's gain, set_camera's orthographic fields, reboot's arguments and start_record's frame_period and fps are optional, and stop_sound takes a play_id to stop one voice.

v0.50.1 - 2026-10-13

Summary:

  • Library types follow newer upstream tags for deftest, monarch and panthera.

Improved

v0.50.0 - 2026-10-13

Summary:

  • Defold 1.14.0 is the default API target (what changed), and its new APIs are typed.
  • Pins built on demand are complete: channel and Defold 1.9.8 pins get all their types (pinning).
  • The API reference keeps a saved version range and marks an outdated one in red.

Improved

  • Defold 1.14.0 is the default API target, so a project that pins no target compiles against it, and code written against 1.13.2 compiles unchanged. Upgrading Defold versions lists the engine and project changes the compiler cannot check, and --defold-target 1.13.2 keeps the previous surface.
  • Defold 1.14.0 APIs are typed: b2d.get_gameobject_id and bullet3d.get_gameobject_id return the game object that owns a physics body. A render script draws to one face of a cubemap render target with the face option of render.set_render_target, the type key of render.render_target and the graphics.CUBEMAP_FACE_* constants.
  • The API reference flags a version range that stops short of the newest Defold release: the To dropdown turns red while it shows an older version, so a range saved on an earlier visit stands out once a newer release is tracked.

Fixed

  • Types on a channel pin — a project pinned to a channel whose release the toolchain builds on demand keeps the types one module declares for another, such as the b2d.aabb that b2d.fixture.get_aabb returns, and functions documented under another module, such as bullet3d.collision_object.get_shapes. The types came out as unknown and the functions were missing; see Pinning the Defold target.
  • Defold 1.9.8 pin — a project whose pinned Defold target is Defold 1.9.8 gets its label declarations. The toolchain looked for that module's reference under the file name a later Defold release gives it, and found none.
  • Saved version range in the API reference — the range picked in the From / To dropdowns holds when you open the API from a guide page, move one end of the range there, or follow a link between API pages. To jumped to the newest Defold release and From widened to the oldest, until the next guide page showed the saved range again.

v0.49.0 - 2026-10-12

Summary:

  • A hand-built MachineInstance needs can, onUnhandled and hasTag to compile.
  • Stricter types: a when that assigns to a field of ctx, a callback that assigns to a field of its event, a machine.matches() in a hook given a string variable or a path that names no state, a state built ahead of the config with a field no state has, and a path below a state with no child states all fail to compile.
  • State machines repeat code with every, put rules on timers, group states with tags, wait for several engine calls with waitGroup(), react to any event no state took with one unhandled hook and resume a saved game from saved state paths.
  • hsm-view glows every runs, dims held timers, glows nothing for a can call and, attached to a running game, glows the rule each inspect move line names.
  • The state machines tutorial builds one robot buddy machine and a charging dock step by step, shows each change as a diff and covers every hsm feature.

Breaking

  • MachineInstance requires can, onUnhandled and hasTag: an object you build yourself and type as MachineInstance, such as a test double or a wrapper around a real instance, fails to compile until it has all three. In a wrapper, add can: (event) => inner.can(event), onUnhandled: (listener) => inner.onUnhandled(listener) and hasTag: (tag) => inner.hasTag(tag); an instance returned by start needs no change; see MachineInstance.
  • A when reads ctx, and every callback reads its event: an assignment to a field of ctx in a when under on or always or in the delay function of an after list, or to a field of the event in a when, a run or an onMove listener, fails to compile. Move the write into run, copy a value out of the event before changing it, and type the parameter of a helper that takes a context class with a private member as Readonly<...> of the class; see Types.
  • A callback's machine takes the machine's paths: inside a hook, a run and a task, machine.matches() no longer takes any string, so a path that names no state and a variable typed string fail to compile there. Correct the path, or give the variable a union of the paths it can hold, such as "/menu" | "/play"; see Types.
  • A state takes only the fields of a state: a state built ahead of the config, in a constant or by a helper, fails to compile when it holds a field no state has, such as label: "idle" beside enter. Remove the field, or keep it outside the state; see Types.

Improved

  • State machines repeat code while a state is active, take rules on timers, name groups of states with tags, wait for several engine calls, react to the events no state took, resume a saved game, complete the paths a callback asks about, answer more about a running machine and show more in hsm-view, the guide gains recipes and states each rule once, and the tutorial teaches every feature on one machine:
    • every — a state runs code each time a delay passes while it is active, such as damage every half second or a rate of fire read from the context; a long frame runs it once, and a run is not a move; see Repeat while a state is active.
    • Rules on timers and always — an after timer takes to, when and run, so a state can run code at a set time without leaving and a timer can wait for a condition once its delay has passed, and an always rule takes run; see Rules on a timer.
    • waitGroup() — a task that starts several engine calls waits for all of them: each add() returns the callback to pass, as in http.request(url, "GET", group.add()), and wait runs its callback once every one has reported; see WaitGroup.
    • A when reads the machine — a rule's when receives the running machine as its last argument, read-only, so a rule can depend on the active states through matches and hasTag, as in when: (_ctx, _event, machine) => machine.matches("/alive/posture/standing"); see Read another region in a when.
    • Path checks — machine.matches() inside a hook, a when, a run and a task takes only the machine's paths, the editor suggests them as you type, and a started instance fits a function that takes MachineInstance<Ctx, E>. A path below a state with no child states, and initial or restoreDepth on such a state, fail to compile where they are written; see Types.
    • Tags — a state lists tags, and hasTag on the instance and on the machine every callback receives answers whether any active state carries one, such as every state in which the player takes no damage; the names are the third type argument of defineMachine; see Name a group of states with tags.
    • can(event) — returns whether a rule of an active state would take that one event, payload included, without moving the machine or running a hook; see Ask whether an event would be taken.
    • unhandled hook — one hook on a state, or on the root, reacts to every event no state took, such as refusing any request by name; the event stays unhandled, so can still answers false for it; see React to an unhandled event.
    • onUnhandled(listener) — calls the listener with each event no active state took, and inspect prints an unhandled line for it; see Listen for unhandled events.
    • Start position — start(ctx, at) takes a list of state paths, such as a saved copy of leaves, and enters those states through an ordinary entry; a path the machine lacks falls back to its closest parent, so a save made before an edit still loads; see Start at saved paths.
    • hsm-view — the page glows an every entry that ran and the timer that fired, dims a timer its when holds back and glows nothing for a can call a hook makes; see Read the code. Attached to a running game, it glows the rule that made each move, which an inspect move line names by its state and key, as in (OPEN: /closed, 0); see Attach to a running game.
    • Animation recipe — the guide builds one knight machine with looping animations, one-shots that finish before the next state, in-between animations between postures and a jump kept until it can play; see Animation states with one-shots.
    • Waiting recipes — the guide shows how a state moves on once something has finished: a chain of child states, engine work counted with waitGroup(), parallel regions joined by an always rule, and a group awaited in a sequence; see Wait for something to finish.
    • Several machines recipes — the guide shows how two machines work together: machines on separate game objects that post messages to each other, two machines in one script where one reads the other, and a machine that runs only while a state of another is active; see Several machines.
    • Shorter guide — the State machines guide states each rule once, in the section that owns it, and shows the few lines that carry each sample in place of whole scripts.
    • One machine in the tutorial — State machines, one click at a time builds one robot buddy machine and a charging dock step by step, shows each change as a diff of the file you are writing, and covers every hsm feature. Live diagrams run the lessons up to save and load, send an event when you press its name, fill the names the machine takes right now, mark a name in every box that has it when you point at one and draw the buddy in its state and reacting to each event, and the later lessons run your own file in hsm-view.

Fixed

  • Timer marks across a hot reload — in a state whose after list reads a delay from the context, each timer keeps its own fired mark when a hot reload reorders the delays. A timer that had fired could fire again, and one that had not could be skipped; see What each instance keeps.
  • hsm-view on an after list — playing a machine whose after is a list glows the entry that fired. The first entry glowed whichever one fired; see Read the code.

v0.48.0 - 2026-10-09

Summary:

Breaking

  • definePrivateMachine is removed: defineMachine takes the optional privateCtx key on its root config, so one function defines every hsm machine; see Private fields with privateCtx. Rename each definePrivateMachine import and call to defineMachine; the config stays as written.

Improved

  • privateCtx takes the starting context: the factory receives the object passed to start, so a private field can start from a field of Ctx, as in privateCtx: (ctx: TurretOptions) => ({ heat: ctx.startHeat }); see Private fields with privateCtx. Give ctx its type there; a factory with no parameter compiles unchanged.
  • An after delay can read the context: after also takes a list such as after: [{ delay: (ctx) => ctx.patrolFor, to: "/rest" }], whose delay is read once each time the state is entered, so one keyed machine serves instances with different delays; see update and after.

v0.47.0 - 2026-10-09

Summary:

Breaking

  • bridge social calls take a config entry id: the library moves to v2.3.0, where bridge.social.share, bridge.social.invite_friends and bridge.social.create_post take the id of an entry in playgama-bridge-config.json and reject a table, and bridge.social.join_community takes only its two callbacks. Replace a table argument with the entry's id, and drop the options argument of bridge.social.join_community.

Improved

  • hsm machines keep private fields: definePrivateMachine takes a privateCtx function on the root config, and its fields reach every hook beside the context while start and the instance's ctx show the context alone; see Private fields with definePrivateMachine. hsm-view lists such a machine and shows the fields in its ctx panel.
  • bridge sends game events: bridge.analytics.send takes an event name and an optional data table.

Fixed

  • build stops with undefined is not an object instead of a type error: some type errors on an object that holds an engine value such as msg.url, hash or vmath.vector3, like an unknown field passed beside it, ended the build with error: undefined is not an object (evaluating 'path.includes') and no file or line. The build now reports the error with its file, line and message.
  • A bridge platform message needed an options table: bridge.platform.send_message and bridge.platform.send_custom_message failed to compile without options, which the library lets you leave out. Both compile with the callbacks straight after the first argument.

v0.46.0 - 2026-10-07

Summary:

  • hsm gains a cheat sheet and hover docs; hsm-view takes the docs site's look, shows icons on its controls, reads object literals, marks a field it cannot read, opens it in a dialog and logs every failed action.
  • A script that exports an hsm machine loads in the game.

Improved

  • hsm documents itself in the editor: every config key, every MachineInstance member and every export of the four hsm modules shows what it does on hover and beside each completion; see Reference.
  • hsm-view has a new look, icons on its controls, fields that check what you type and open in a dialog, and a log line for every failed action; see Run the machine:
    • Look — the page uses the docs site's palette in light and dark, and its buttons, fields, dropdowns, layout toggle and log checkboxes show hover, focus and disabled states on a muted bar.
    • Icons — Start, Play, Pause, Step and the layout toggle's List and Stacked each draw an icon before the label, and the ctx tree's expand and collapse arrows are icons.
    • Fields — the starting context and the event payload take a TypeScript object literal such as { enter: true, from: 'pad' } as well as JSON, and a field that cannot be read is outlined in red while you type, with a message that names where the mistake is. A button beside each field opens its text in a dialog with a multi-line editor, where Start or Apply writes it back.
    • Errors — every failed action adds an error line to the log, and one that belongs to no field also shows in a popup that closes by itself. The banner under the bar shows what still holds, such as a lost connection or a halted machine; see Errors.
  • The State machines guide has a cheat sheet: three tables pair a task with its solution and a snippet to copy, covering each common state config part, the instance, context, event and path types read off the machine with typeof and ReturnType, and five ways to type self; see Cheat sheet. New sections show how to restart a machine and how a restart works with hot reload.

Fixed

  • A script that exports an hsm machine no longer stops the game: the Lua module written beside a script for its exports required the hsm or timers module by a path Defold cannot load, so the game failed with could not be found, or with an InvalidPathException on Windows. It now requires the module the way the script does; see Exporting a value from a script itself.

v0.45.0 - 2026-10-06

Summary:

Breaking

  • hsm update hooks return a machine path: an update hook that returns a plain string no longer compiles. Return one of the machine's full paths or undefined, and add as const to a hook declared outside the config (() => "/grounded" as const). The MachineConfigError and DefinedMachine types are removed, because defineMachine returns a Machine for every config that compiles; see Types.

Improved

Fixed

  • model.get_blend_weights example sets the wrong weights: the example wrote the second and third weights where its Lua sample writes the first two; it now writes w[0] and w[1].

v0.44.1 - 2026-10-05

Summary:

Fixed

  • hsm-view opens to a blank page: the browser page failed as soon as it loaded, with T is not a function in the browser console, so no machine, source or controls appeared. The page now loads and shows the machine picker, your source and the controls.

v0.44.0 - 2026-10-05

Summary:

Breaking

  • hsm keys and types are renamed: the transition keys target, guard and actions are to, when and run, a state's invoke is task, and the types InvokeStart and TransitionAction are TaskStart and MoveAction; an old key fails to compile, in on and always rules alike, and hovering it names its replacement. A task may return a cleanup, so brace an expression body that returns anything but a function, such as (_ctx, finish) => timer.delay(...); see Events and transitions and Engine callbacks.
  • hsm reenter is gone and a self-target restarts: a to naming the state the rule is on exits and re-enters that state, restarting its timers and task, where it used to keep the state and restart only its children; a self-targeting after repeats. Write reenter: true as the plain path, and restart only the children by naming the child to start in; see Events and transitions.
  • hsm message events carry the sender: messageEvents(...).toEvent takes the on_message sender as a required third argument, and every MessageEvent has an event.sender that when and run can reply to. Pass sender to each toEvent call and add it to any MessageEvent you build by hand; see The message bridge.
  • hsm instances gain onMove and leaves: MachineInstance has required onMove and leaves members, so add or forward both on any object you build as a MachineInstance (a test mock, a proxy). Where a parameter typed MachineInstance<Ctx, E> receives an instance with more event types, widen its E to the machine's full event union; see Debug a machine.

Improved

  • hsm-view runs a state machine in your browser: bunx @defold-typescript/cli hsm-view <file> [name] serves a local page that runs the machine from source, tints its active states in the code, glows each rule that fires and, more dimly, each on entry whose when turned the event away, and lets you send events, play or step time, edit its ctx and read a log, reloading live on every save; see hsm-view. It can also attach to a game launched from the editor and tint the states of an inspected instance as the game moves it; see Attach to a running game.
  • hsm machines are easier to script, resume, branch, split into regions, debug, reload and budget:
    • Scripted sequences — a task may return a cleanup the machine runs on every way out of the state, and sequence(async (ctx, signal) => ...) from @defold-typescript/types/hsm/async builds one whose await signal.wait(seconds) never resumes after the state is left. Any other await in a sequence can resume after the state is left, so check signal.aborted after it; see Scripted sequences.
    • Restore on entry — restoreDepth on a compound state enters the children that were active when it was last left instead of initial, that many levels down or every level with "all", and a parallel state does not count as a level. The memory is per instance and survives a hot reload, while a target inside the state still lands where it names; see Resume with history.
    • always transitions — always on a state lists targets taken right after any move that leaves it active, deepest state first, the first passing when(ctx) winning, reported to onMove with the cause "always"; an 11th always move in a row throws instead of looping. See Move on at once with always.
    • Parallel regions — a state with type: "parallel" keeps every child active at once, ordered by child name in Unicode code point order, each region taking its own events, update ticks, after timers and always moves, while an event no region takes bubbles above it. leaves lists every active leaf, path stays the first, and the inspector draws them all; see Run regions side by side with parallel.
    • Debug inspector — onMove(listener) on a machine instance calls the listener after each move with the old and new state path, the cause and the event, and returns a function that removes it. inspect(instance, label) from @defold-typescript/types/hsm/debug uses it, in debug builds only, to log the starting state and each move with every active leaf, backslash-escaping brackets, parentheses, commas and colons inside a logged name, and to draw those leaves over a game object, giving a repeated label the next unused ordinal (enemy#2); see Debug a machine.
    • Hot reload — a definition made with defineMachine<Ctx, E>("key") reaches running instances on their next send or update after a reload, with no on_reload: kept states keep their context and timers, and a removed state falls back to its surviving parent's initial, reported to onMove with the cause "reload". See Hot reload.
    • Performance — 200 objects each running a three-level machine cost about 0.05 ms per frame in the stock engine, and update and send build no tables. Performance records the numbers and shows how to hoist constant events off a hot path.

Fixed

  • Strict installs load the transpiler: @defold-typescript/transpiler declares typescript, so an install with strict dependency resolution (pnpm, Bun's isolated linker) no longer fails to load it.
  • hsm after timers on a parent no longer fire late: when an update hook transitioned one of its children, the parent missed that call's dt, so its timer fired one tick late per such transition. Every active state now counts the dt of every update call, as the State machines guide describes; a timer due on the same tick a hook transitions still waits for the next call.
  • The State machines tutorial no longer jumps in Safari: the live diagrams on State machines, one click at a time pulled the page back while you scrolled, pinning it short of the bottom. They now redraw only what changed, and a diagram scrolled out of view pauses until you scroll back to it.
  • Four declarations match what Defold accepts and returns:
    • go.set and go.get take and return a string, the value of a text property (Defold 1.13.2 or later).
    • b2d.body.get_transform and b2d.body.get_mass_data declare only the table they return, without an opaque-handle overload.
    • zip.pack takes its entries as a list; a bare path string, which the editor rejects, is a compile error.
    • http.server.route accepts an OpenAPI table right after the path or after the method.

v0.43.0 - 2026-10-02

Summary:

Improved

  • hsm, a typed hierarchical state machine library, ships with the toolchain: import { defineMachine } from "@defold-typescript/types/hsm" and import { messageEvents } from "@defold-typescript/types/hsm/defold" type-check in the editor and the build, which writes only the modules your code uses to defold_typescript_hsm/ under the output root, with no source map; machines type their events, context and state paths, every target, initial, path and matches() uses one full path from the root such as /on/dim, a stopped machine's path is undefined, and an unknown or relative target, a bad initial, a state name containing / or an after key that is not a non-negative number fails at definition with the same message in Defold as in TypeScript, the path mistakes at compile time too. The State machines guide covers the model first (transitions, timers, run-to-completion), then one instance per object on self, the message bridge, engine callbacks, a walkthrough that migrates the platformer example's player and a reference table, and every sample on it compiles against the shipped declarations.
  • State machines, one click at a time joins the tutorials for readers who have never used a state machine: eleven short parts, from a two-state lamp to timers, waiting on work and wiring a machine into a script, with eight live diagrams that run the real hsm library and samples that all compile against the shipped declarations.

v0.42.0 - 2026-10-02

Summary:

  • build and watch drive the open Defold 1.13.2+ editor: they compile your project there or build and launch the game, and report each issue at its TypeScript line.
  • The API reference shows each function's history across Defold releases as it applies: overloads added or removed in a release are summarized, and a changed signature reads as one function with its earlier form below it.
  • API search hits open the exact member they matched.

Improved

  • build --editor-compile, build --editor-run and watch --editor-compile drive the open Defold 1.13.2+ editor: build compiles the project or builds and launches the game once the Lua is written, printing the engine's URL (--editor-focus brings its window forward) and exiting 1 on failure, while watch compiles after every successful build and project file change, keeps running on a failed compile, and ships as the defold-typescript:watch-ec and defold-typescript:watch-hr-ec mise tasks. Each issue shows at its TypeScript line, --json carries the result as editorCompile or editorRun (one editorCompile event per compile under watch), an older or missing editor is reported in one line without failing, and every other command rejects the flags; see Compile in the editor, Run in the editor and watch.
  • Overloaded functions whose forms span different Defold releases open with a summary in the API reference, such as "1 overload added in Defold 1.13.2" on go.property, and a form dropped in a release shows below the forms as a "Removed in Defold …" line led by a C chip.

Fixed

  • The API reference shows each function's history as it applies:
    • go.property forms — the go.property(name: string, value: string) form reads "Since Defold 1.13.2" instead of showing as available on every version, while the other go.property forms keep their full span and the function's heading reads Changed.
    • Signature changes — a function whose signature changed between Defold releases, such as b2d.get_world or json.decode, renders under its current signature with a "Signature changed in Defold 1.13.2 — before: …" line led by a C chip, instead of listing the replaced form as a second overload.
    • One score per function — a function whose signature changed between Defold releases, such as json.decode, go.get or gui.set, reads Changed on its heading and counts once as changed in the namespace title and sidebar pills, rather than also as new.
    • "On this page" outline — an entry and its hover tooltip show the heading's colored N/C/D/G/U chips instead of plain trailing letters, and hide a chip the version window hides; the tooltip shows the 3 overloads pill in the signature's code font instead of ....
  • API search hits open the member they matched. Searching get_position lists go.get_position by name, and clicking a hit in the search box or on the search page scrolls to that member's heading instead of the top of the go page; types and their fields land the same way, such as b2d.joint.JOINT_TYPE or monarch.monarch.ShowOptions.no_stack.

v0.41.0 - 2026-09-30

Summary:

  • Defold 1.13.2 is the default API target (what changed), and its new APIs are typed, including the bullet3d physics namespaces and text script properties.
  • The breaking changes catch at compile time what used to fail when the script ran: a missing required argument or table field, a call the engine's Lua bindings reject, or a value typed differently from what the engine returns; options.index is also 1-based again.
  • Declarations stricter than the engine are relaxed, curried go.get<P>() and go.set<P>() calls reach the engine, and reload and watch --hot-reload work against a 1.13.2 editor.
  • Hovers and the API reference state the base of every index and show each example as its own TypeScript block with the engine's Lua sample beside it.

Breaking

Improved

  • Defold 1.13.2 APIs are typed: the bullet3d 3D physics namespaces, label.get_layout_objects and gui.get_layout_objects, the proxy_loading, proxy_ready, proxy_error and text_object_* messages, and window.WINDOW_EVENT_ICONIFIED, which isWindowEvent and window.set_listener accept. Tables the 1.13.2 reference names, such as image.load_result, are named types, and the constants it newly documents, render.CONTEXT_EVENT_CONTEXT_LOST and render.CONTEXT_EVENT_CONTEXT_RESTORED, have entries on its API reference page.
  • Text script properties on Defold 1.13.2: a string default in defineScript({ properties }) registers a text property typed string on self, a deprecated direct go.property("greeting", "Hello") compiles too, and on an older target build and watch refuse any script declaring a property of either form that may hold a string, naming the property and both versions. label.properties declares a writable text, so go.get<label.properties>()("#label", "text") reads a label's text.
  • editor.platform is typed as the four platform ids it can hold, so editor.bob({ platform: editor.platform }) compiles as the reference writes it.
  • Every engine index states its native base in hovers and the API reference as one bold sentence led by a marker, "⚠️ 1-based; passed to Defold unchanged." or "0️⃣ 0-based; passed to Defold unchanged.", on the slot itself or naming the table field it covers, including bases the reference states only in a function's notes or description: the geometry indices of resource.create_atlas, resource.set_atlas and resource.get_atlas, and the mipmap of resource.set_texture; the editor-script image.pixels marks the base of its coordinates the same way. The guide's Engine indexes use Defold's base lists every such position by base in a table built from the same data, so it names exactly the positions the hovers mark.
  • Library and extension indexes state their base the same way, naming the library, as in "⚠️ 1-based; passed to gooey unchanged.": the API reference notes it on parameters, returns, each value of a multi-value return that holds a position (tile_x, tile_y and array_id from tile_raycast.cast), table fields, callback arguments and class fields of every library that takes or returns a position. Editor hovers show the same note for every library declaration, such as bridge, druid, gooey and tile_raycast, and for each extension resolve types from a curated page, such as steam and spine.
  • API symbol names in the guide and changelog link to their reference entry: inline code such as go.get, render.RENDER_TARGET_DEFAULT, the global function hash or the global type Vector3 opens that entry in the API reference.
  • Every function with several examples documents each one as its own TypeScript block, with the sentence that introduces it above, in hovers and the API reference: among them gui.set, render.draw, sys.load_buffer, json.decode and editor.bob, each of which showed one welded block. The API reference does the same for go.get and go.set, including their named-property and sub-component cases.
  • Every TypeScript example in the API reference has a Lua tab beside it showing the engine's original sample, in function examples and in code samples inside descriptions and parameter docs; the selected tab's badge is highlighted.
  • The ten in.* library types are checked against britzl/defold-input 4.8.0, and their API reference pages name that tag; the declarations are unchanged.
  • Library parameters typed as string-keyed tables accept an object literal as well as a LuaTable, such as the components of decore.create and the nodes of panthera.create_gui; tables a library returns stay LuaTable.
  • druid types follow Insality/druid 1.4.0: the button, drag, scroll, input and slider styles take optional hover cursors, such as druid.druid_button_style.ON_HOVER_CURSOR, a slider exposes its druid.druid_slider.hover component, and rich text word metrics report druid.druid_rich_text_metrics.visible_width.
  • Overloaded functions in the API reference lead with their description: the shared description and its warning sit above the forms and the shared example follows the parameter tables, so go.property reads as one description followed by its eight forms, and its description, in hovers too, states that a string default needs Defold 1.13.2.

Fixed

v0.40.0 - 2026-09-26

Breaking

Improved

  • Vectors and rotations is a new tutorial on the math behind movement — positions, vectors, speed, dt, rotation, the dot product and local versus world space, one game problem per lesson, ending with a ship that drifts through space. Its fifteen figures follow the site font and the light/dark theme and stack their side-by-side panels on a phone, and every TypeScript snippet on the page type-checks against the shipped declarations.
  • bridge moves from v2.1.0 to v2.2.0, adding platform.launch_source, platform.data and the post-reward pair social.is_post_reward_supported / social.get_post_reward. share, invite_friends and create_post also accept a config-entry id as options, and create_post takes an optional payload string before its callbacks; every existing call still compiles.
  • An overloaded function in the API reference renders as one block, such as msg.url: its heading reads name(N overloads) with a teal count badge plus the return type every form shares, the syntax-colored call forms come ahead of any toolchain note like the one on go.property, and each fact the forms share is stated once while each form keeps its own description, example, parameters and returns, as on vmath.lerp. Forms that are one function's signature across Defold releases, such as gui.set, show only the newest example; the function overview and the "On this page" outline show the same teal badge, the overview nesting each form beneath it; and the b2d.shape body, shape_index form documents both of its arguments.
  • Each version note in the API reference leads with the N/C/D chip its fact maps to instead of a grey bullet, such as the green N before Since Defold 1.13.0 on b2d.body, and the chip stays when a narrower release range hides the heading's. In an overload block, a note every form shares sits once above the forms, and a note for one form sits right under that form's signature.
  • The Nakama server API spec (heroiclabs/nakama) that nakama is checked against moves from v3.40.0 to v3.41.0. The client types you import still come from heroiclabs/nakama-defold v3.4.0 and are unchanged.

Fixed

  • An extension whose .script_api writes a type as a list (type: [table, string]) is typed as that union by resolve instead of unknown.
  • Symbol names mentioned in API reference prose link to their reference on the published site instead of opening a missing page.
  • Math symbols and other special characters in the engine reference show as characters in editor hovers and on API reference pages, such as P ⋅ Q = |P| |Q| cos θ for vmath.dot, instead of entity source like &#x22C5;.
  • Declarations that the engine's own examples or descriptions contradict are corrected, so code written the way the reference shows it type-checks:
    • go.get / go.set — the key option accepts a string as well as a hash, keys takes an array of hashes or strings, and go.set accepts an array of vmath.vector4 to set a material property array. go.delete(true) deletes the calling object and its children.
    • Component property keys — go.get<model.properties>() reads "texture0" through "texture7" instead of the textureN placeholder from the model reference, sprite adds "texture0", and a new mesh.properties catalog declares "vertices", all typed Hash.
    • render.constant_buffer() — the buffer takes named constants, single or array, as in constants.tint = vmath.vector4(1, 1, 1, 1).
    • Render targets and textures — render.set_render_target, get_render_target_width / _height, set_render_target_size and enable_texture take a render target resource by name, and set_render_target takes render.RENDER_TARGET_DEFAULT and a list of graphics.BUFFER_TYPE_* constants as options.transient. enable_texture binds a render target or a numeric texture handle, disable_texture takes a texture unit, and set_camera takes a camera URL string.
    • String-keyed tables — compute.set_textures, material.set_textures and the http.request headers accept an object literal as well as a LuaMap. collectionfactory.create properties is keyed by instance id, as a LuaMap<Hash, …> or an object literal, so a table keyed by property names such as { speed: 2 } reports an error.
    • pprint — takes any number of values, as in pprint("MOUNTS", mounts).
    • gui.set — takes a vmath.matrix4 material constant, a hash such as a runtime texture, and a string options.key such as "my_font_name"; gui.set_rotation takes Euler angles as a vmath.vector3.
    • b2d.shape — every function that takes a shape handle also takes body, shape_index, as in b2d.shape.get_shape(body, 1), and set_shape may omit update_mass.
    • Atlas animations — playback in resource.set_atlas, create_atlas and get_atlas is a go.Playback, so it takes go.PLAYBACK_LOOP_PINGPONG instead of rejecting every constant.
    • sys.save / sys.serialize — take a Lua sequence such as ["my_value"].
    • Buffers — buffer.create takes its stream declarations as an array of { name, type, count } records whose type is a buffer.ValueType. stream.length() returns the element count and compiles to Lua's #stream, and buffer.get_bytes takes the stream name as a string.
    • msg.post — a message id with no declared payload also accepts a Lua sequence, such as [t_volume].
    • http.request, sprite.play_flipbook and collectionproxy.load callbacks — receive the documented response table (status, response, headers, progress and range fields) and completion message (current_tile, id), with Hash message ids and Url senders, instead of unknown.
    • socket.newtry / socket.protect — socket.newtry() may omit its finalizer, and a try function returns the value it unwraps, such as the client from try_(conn, err) after const [conn, err] = socket.connect(host, port), while rejecting an undestructured multi-return that Lua would receive as one always-truthy table. A protected function returns nil plus the error message.
    • render.CONTEXT_EVENT_CONTEXT_LOST / _RESTORED and graphics.SEMANTIC_TYPE_* — declared; the engine defines them, but the reference names them only in prose. The SEMANTIC_TYPE_* constants follow each release's own list: none on 1.12.4, twelve on 1.13.0, and SEMANTIC_TYPE_MORPH_TARGET_WEIGHTS from 1.13.1.
  • Every hover and API reference example type-checks at the strictness defold-typescript init sets up. Examples return script state from init (such as render.draw and vmath.lerp), check a value that can be missing before using it (image.load, camera.screen_to_world), use the constants the declarations export (gui.EASING_LINEAR, sys.REQUEST_STATUS_FINISHED), give each of several examples on one page its own scope (sys.get_host_path), and destructure a multi-return before handing it to a try function, so the socket.newtry and socket.protect examples catch errors.

v0.39.0 - 2026-09-23

Improved

  • sprite_repeat and node_repeat (Dragosha/defold-sprite-repeat, tag v0.3) now have types, so resolve gives a project that depends on the library typed imports for tiling a sprite or GUI box node texture, including the animate, stop and update calls on the handle create returns.
  • resource.create_texture accepts page_count, the array-texture page count the engine reads and upstream's own example passes, so creating a texture array type-checks without a cast. The reference's own <dl> omits the field; every documented field it lists stays as the reference declares it.
  • Native extensions that ship no .script_api can now be typed: resolve writes a curated namespace into .defold-types/extensions/ for DAABBCC (daabbcc), defold-sharing (share), defold-uuid4 (uuid4) and defold-tile-raycast (tile_raycast) once the archive's ext.manifest confirms the match, resolve --json reports each as typeSurface: "vendored-native", and each /api page defines the result and option shapes its signatures name. Where an extension's bundled annotations disagree with its C++ source, the types follow the C++, so daabbcc.rebuild_all(undefined, full) passes the flag in the second position the runtime reads.
  • The API reference shows authored TypeScript examples. 329 functions carry a hand-authored body, and both the canonical /api/<namespace> pages and the version-pinned ones such as /api/defold-1.13.1/resource render it wherever the example's source hash resolves; an example with no resolving authored body shows the reference's own Lua — see resource.
  • Every documented constant enum has a name you can write. A parameter that spelled out 41 branded gui.EASING_* arms reads gui.Easing — exported from the namespace it belongs to (gui, go, graphics, render, window and the rest), with separate names where a getter and its setter accept different members, such as window's DimModeState and DimModeStateSettable — so signatures and hovers stay legible and your own wrapper can take one instead of falling back to number. Each alias has an API-reference entry listing its members, and every mention links to it from the signature and from the Parameters and Returns breakdown beneath it, landing on the entry for the version you are reading.

Fixed

  • Four defect classes are cleared from the @example shipped on each declaration, so many more of them compile — and build what they then use — when you copy one out of a hover or the API reference. Examples outside these classes still carry type errors, mostly wrong property and argument types.
    • Wrong script factory — 21 gui and render functions called defineScript, which a gui script or render script cannot import. Each now calls the factory its own script kind exports, defineGuiScript or defineRenderScript.
    • Undeclared names — 49 functions used names the example itself never introduced, leaving srcbuffer, url or self undefined. Each body declares every ordinary local with the real API that produces it, gets self the way real code does — from the script factory its own kind exports, or as a parameter where the example is documented across several kinds — and what it declares is a resource the rest of the body validly uses: a render target is freed once from a teardown hook and declares every attachment it is queried for, and a resource array texture narrows the resource and image it loads before reading them, holds every page written to it, and is created at the dimensions of the image it decodes — on every pinned defold-target that ships the example.
    • Untyped helper parameters — a helper in 16 examples left its parameters untyped, which the strict: true project init scaffolds rejects with TS7006. Every parameter now carries the type the API it is passed to declares, or the self fields the body reads.
    • Several examples run together — 35 functions, across go, gui, render, resource and the script callbacks, document more than one example and shipped them concatenated into a single block; 15 of those blocks stacked two or more export default and could never compile, and the other 20 compiled only as one welded program, with the sentences separating the examples folded into the fence as comments and colliding names renamed to keep it valid. Each example is now its own @example block in the hover and on the API reference, led by the sentence the reference writes above it, and carrying everything that example needs on its own.
  • Reference descriptions reach you whole, in an editor hover and on the API reference. Three ways the reference's own markup broke the render are repaired in the one converter both surfaces read.
    • Unclosed code block — three resource parameter and return descriptions open a Lua block upstream and never close it, swallowing everything after it; the closing fence is supplied now, so a hover still shows the @example that follows and /api/resource renders all 24 of its symbols outside the block.
    • Heading welded into the Lua — ten resource, go and gui examples pack several examples into one highlight block using the reference's own fence markers, which rendered as lines of code; each example is a code block of its own now, with the heading as prose between them.
    • Bullet with no value — 41 resource bullets showed an empty - with the value they described adrift below the list, on every pinned defold-target; each marker now carries its value.
  • watch no longer repeats "attached to Defold editor" after the machine sleeps or the editor's console connection drops, and no longer repeats the editor version warning with it.

v0.38.0 - 2026-09-21

Improved

  • Messages can be typed where they are sent and handled, with no program-wide declaration required — see Ways to type your messages. An undeclared string remains a valid msg.post message id; the one build change is the onMessage fix below.
    • msg.post completion lists every built-in id and every id declared in CustomMessages, and any other string still compiles.
    • Handler annotation — annotating a handler's message in onMessage declares that id for the script, a numeric key under its string form (1e3 is "1000"), and ScriptMessages<typeof script> reads the ids back off defineScript, defineGuiScript or defineRenderScript.
    • Typed receiver — msg.url<M>(...) returns an address that makes msg.post complete and check the receiver's own ids.
    • Scene address — scene-types links each script component's address to the defineScript source that builds it, so msg.post("/logic#wave", ...) completes and checks that script's ids with no import.

Fixed

  • An onMessage handler under a computed key such as [WAVE] (with const WAVE = "spawn_wave"), or written as shorthand { onHit }, built without an error but never ran. A key like [WAVE] now handles "spawn_wave", and any handler the build cannot wire up fails the build at that line — see the examples.

v0.37.0 - 2026-09-20

Breaking

  • A pure-Lua library that ships its own .script_api now gets this toolchain's curated types instead of an ambient namespace generated from that doc. resolve matches each dependency against the vendored corpus first, so a confirmed match such as boom or bridge is imported by its require path (import * as boom from 'boom.boom') and the stale extensions/ namespace an earlier run wrote is pruned with its tsconfig entry. A match the archive does not confirm changes nothing: it is reported as an unverified library only when the dependency is asset-only, and otherwise keeps its own .script_api namespace with no entry and no warning.
  • init writes no debug file; setup-debug writes the whole debug path. The launch.json configuration, the defold-debug.ts Bun launcher and the Local Lua Debugger recommendation arrive with the game.project dependency, the ambient declaration and the entry-script bootstrap, so a scaffolded project stops advertising a debugger nothing has wired; a launch.json the command cannot parse stops it by name with the project left untouched. upgrade and init . --force refresh the two derived fields of a launch configuration already present and create none.
  • Five return types now carry what the engine actually returns, matching the reference and the @example shipped beside them. Three of them gain values that can be absent, so the call sites below need a ?? default or a narrowing check.
    • resource.get_render_target_info — the per-attachment fields (handle, width, height, depth, mipmaps, type, buffer_type, texture) sat beside the top-level handle instead of inside the documented attachments array. Read them as info.attachments[0].handle; texture is optional, since the reference documents it only for a render target passed in as a resource.
    • window.get_safe_area — the eight keys were wrapped in a safe_area level the engine never returns. Drop it: window.get_safe_area().inset_left.
    • sys.get_sys_info — device_model, manufacturer, device_ident and user_agent are optional, since the reference gates each on iOS, Android or HTML5 and Lua leaves the key out elsewhere. The other fields are unchanged.
    • sys.get_ifaddrs — address and mac are optional, which the reference has always said: "might be nil if not available".
    • b2d.get_body — returns undefined when the url names no collision object, as the reference's "Otherwise nil" says.

Improved

  • The scaffold now follows your tsconfig.json include and outDir instead of assuming src/. init seeds the starter main.ts under the first include pattern that admits its own main.ts — an exact-file include such as ["src/main.ts"] among them — and points the generated main/main.collection at the component build emits for it, reporting the patterns it searched instead of scaffolding when none of them does. The managed .gitignore, biome.json and Lua.workspace.ignoreDir rules read the same include — a re-init (or an upgrade) retires the older src-shaped rules, so a generated .lua module shows up in git status unless you set outDir, and a biome.json you have hand-edited to hold comments is reported for you to edit rather than rewritten.
  • resolve --json now says which type surface each dependency contributed. Every extensions[] entry carries typeSurface — "extension", "vendored-library" or "none" — so an empty namespaces reads as the normal outcome it is rather than a failure, and summing extensions[].namespaces with libraries[].modules counts each module exactly once. Every declared dependency keeps its entry, pin fields included.

Fixed

  • upgrade and init . --force now leave a current .vscode/launch.json exactly as you wrote it. Both rewrote the file from its parse tree on every run, dropping your // comments and hand indentation even when neither derived field had changed.
  • resolve now clears the extension surface when nothing declares one. Removing the last .script_api dependency — or every [dependencies] entry — used to leave .defold-types/extensions/ and its "extensions" tsconfig entry behind, so retired ambient declarations kept loading; all three surfaces now reconcile to exactly what is declared.
  • Debugging now follows your configured sources instead of assuming src/, on both ends. setup-debug picks the entry script, cleans up stale blocks and writes the ambient lldebugger.debug.d.ts next to that script off your include, refusing a target that is not a configured production source by name and cause — outside the patterns, a declaration file, or under a generated or dependency tree such as build/node_modules; and the launch.json it writes derives its scriptFiles and scriptRoots from include and outDir, so a breakpoint binds in a gui script, a render script or a plain .lua module wherever the build writes it. upgrade, and init . --force, rewrite those two fields in place when your inputs move, leaving the rest of the configuration alone.

v0.36.0 - 2026-09-17

Breaking

  • render.clear's buffer table is now keyed by the three graphics.BUFFER_TYPE_* constants its reference names, not by any number. LuaMap<number, number | Vector4> no longer compiles — LuaMap's key type is invariant — so declare it LuaMap<render.ClearBufferKey, number | Vector4>, an alias exported on the default surface and every pinned defold-target (Lua table constructs).
  • build and watch now reject three output arrangements they used to emit silently, each naming the file and what to change. build exits non-zero having written no Lua; watch reports the same diagnostics and keeps watching, rebuilding once you fix the file. Type-only imports, and a require with no TypeScript source behind it such as a library's Lua or lldebugger.debug, are still left alone.
    • Unreachable require — every emitted require is checked against the outputs the build writes, naming the importing file, the path Defold looks for and the path written. A dot in a source name is rejected rather than repaired, so rename the source.
    • Unsplittable script — a script whose exported values cannot be told apart from its lifecycle hooks: a top-level binding reassigned in one and read in the other, whatever the rebinding's spelling, or effectful top-level work above an exported declaration. Both are fixed by the module singleton script state already teaches.
    • Contested output path — a path claimed by two sources, or one already holding Lua the build did not generate, reported before anything is written so that file is left byte-for-byte alone. The generated lualib_bundle.lua and defold_typescript_timers.lua are inside the same contract, so a hand-authored file at either output-root path has to be renamed.

Improved

  • A script can now export runtime values other sources import. A source that calls a lifecycle factory and exports values builds into two files — the component, and a companion Lua module beside it (src/door.ts -> src/door.ts.script and src/door.lua) carrying exactly the exports and the declarations they reach, so a value only the script uses stays in the script alone. The component requires the companion rather than redeclaring it, so an exported object is one table for the script and every importer, under a configured outDir as much as alongside the sources (script state).
  • Lua table constructs is a new guide page on writing a table the engine reads by constant key, such as render.clear's buffer table: why the object literal does not compile, the checked LuaMap route and the inline cast, and the mapped type that looks like the fix while silently accepting a key from another family.
  • Script lifecycle now lays out all three ways to type self and what inference costs. It covers init(self): State and defineScript<Props, State> beside the inferred default, why one type argument cannot sit next to properties, and that a type argument describes state without creating it — a field no init writes is nil on a fresh instance.

Fixed

  • A project with a configured outDir now loads what build writes. Every emitted require — a cross-file import, and the generated lualib_bundle.lua and defold_typescript_timers.lua — used to keep its source-tree spelling while the file was written under the outDir, so Defold found nothing at load time; each now names the path the build wrote. An outDir whose own name contains a dot can be named by no require at all and fails the build before anything is written.
  • A timers-only project now gets the lualib_bundle.lua its runtime requires. The generated timer runtime has always required the bundle, but nothing asked for it to be written unless some source also used a helper like Object.keys, so such a project loaded a file the build never wrote.
  • The font namespace now exists on the default surface. It shipped in the per-kind subpaths and every pinned defold-target but was missing from the package's own entrypoint, so font.add_font(...) failed to compile for a project that imports @defold-typescript/types directly.
  • Three API reference code examples now compile. render.clear passed an object literal where the signature takes a LuaMap, zlib.inflate's sample payload used string escapes TypeScript rejects outright, and factory.create put two export defaults in one block; each is now copy-pasteable, and every hand-authored example is type-checked against the surfaces that ship it so a new one cannot regress.
  • API reference Parameters and Returns entries now show the same type as the signature above them, on each overload's own row. Slots whose real type the typings recovered — render.clear's buffer table, render.enable_state's state constant, b2d.body.create_fixture's fixture-definition table, and every other curated mapping, documented constant or recovered options table — used to read Record<string | number, unknown> or Opaque<"constant"> in the breakdown while the signature showed the branded type you actually pass.

v0.35.0 - 2026-09-16

Breaking

  • A constant-typed function argument whose reference documentation names constants the typings declare now accepts only those constants. Passing such an argument a generic Opaque<"constant">, a constant from another family (gui.PLAYBACK_ONCE_FORWARD into model.play_anim), or the result of window.get_dim_mode(), which can be DIMMING_UNKNOWN, into window.set_dim_mode no longer compiles; pass the documented constant instead (enum constants).
  • @defold-typescript/types no longer declares iac, iap, push or webview, on the default surface or any pinned defold-target. A project that calls them must add the extension as a dependencies#N entry in game.project and run resolve, which types them like every other extension (native extensions).

Improved

  • Documented constants now compile where the reference says to pass them, and getter results compare against their constants. gui.animate(node, gui.PROP_COLOR, to, gui.EASING_INOUTQUAD, 0.5) and the other gui setters, render.enable_state(graphics.STATE_DEPTH_TEST) in render, and the profiler, model, window and buffer metadata calls type-check, and sys.get_connectivity() === sys.NETWORK_CONNECTED is no longer rejected as a comparison that can never be true.
  • CLI failure lines now read defold-typescript <command>: error: <message> and non-fatal problems … warning: <message>, with the word bold red or yellow on a terminal, and the ERROR:/WARNING: tag of Defold console lines forwarded by watch and reload is colored the same way. resolve's scene-source warnings now carry the command prefix, --no-color, NO_COLOR, TERM=dumb and --json turn color off, and --json payloads are unchanged (terminal output).
  • watch keeps itself attached to whichever Defold editor is running, and checks that editor's version.
    • Attaching — it looks for an editor about once a second while none is attached, so an editor opened at any time is attached and one that quits is reported, without waiting for a file save. Runtime errors from a game launched before your first edit reach the terminal straight away, and an editor whose console fails to open is retried at growing intervals until it opens or the editor quits.
    • Version check — an editor attaching after startup is version-checked: a mismatch with a concrete defold-target pin prints the set-target --detected notice, an unpinned watch names both versions and asks for a restart, and --json reports it as an editorVersion event. A version matching the target, the one startup compared, or the last one reported is not repeated, a check whose own editor quit or was replaced before it finished reports nothing, and the exit status is never affected.

Fixed

  • render.render_target({...}) and vmath.euler_to_quat(v) now compile. The engine accepts a lone parameter table and a lone vector3 — the calls the reference's own examples make — but the typings required the two- and three-argument forms; both spellings of each call now type-check on the default surface and on every pinned defold-target.
  • Hand-authored engine overloads now show every overload form on the canonical API reference pages. go.get, go.set, go.property, msg.post, msg.url, render.render_target and the vmath generics list each arm on their unversioned /api/<namespace> page, which previously showed a single stale generated signature; the same arms are one entry each in llms-full.txt.
  • reload exits 1 when the editor console closes or fails before its --wait window ends. Such a reload used to exit 0 with "no error observed" even though the rest of the window went unread; --json now reports consoleWindowComplete so an empty consoleErrors can be trusted only when it is true.
  • watch keeps an editor that replaced another one attached when the old editor's console closes. The replacement is no longer detached and announced a second time, and its runtime errors keep reaching the terminal.

v0.34.0 - 2026-09-13

Improved

  • Every Defold library is now listed under Libraries › defold, which leads the sidebar and the Libraries page marked (official). Each .script_api a defold GitHub org repo ships gets a page at its pin, with setup steps matching that release, tag or commit, and each repo with no typed API gets its own icon-marked page and sidebar entry, such as extension-qrcode, describing what it ships with the same GitHub pin and setup steps as a typed library page — except that placeholder repos show no install step and fork-only repos start with forking; iac, iap, push and webview moved there from the engine reference, and their /api/ links still work.
  • Defold library pages show each extension's constants, code examples, callback arguments and optional parameters. Pages such as admob and iap carry a Constants section and the upstream usage examples, list a callback's arguments and a table's fields nested under their parameter, and mark optional parameters with ?.
  • Lua and TypeScript code samples in the guide and API reference are labelled with their language. A small badge shows the language's logo and name beside a sample's file name, or on the block's top edge when it has none, and copying a sample never includes it.
  • Platform and caution markers in the API reference now show as platform logos and icons whose label appears on hover or keyboard focus, with caution icons tinted like a warning callout. Notes such as "iOS only" or "attention" on pages like sys and iap used to vanish or read as [icon:ios] bracket text; library cards and symbol tooltips now drop the brackets.

Fixed

  • A native extension's branded engine types now type as brands instead of silently becoming any. The materialized extension surface named a brand import that resolved nowhere from where it was written, so under the scaffold's skipLibCheck every Hash, Url, Vector3 and node handle in an extension's signatures widened to any and stopped catching wrong arguments — worst on extensions like Spine, whose signatures are branded almost throughout. Extensions also gains a section on extensions that add members to an engine-owned namespace.
  • webview.create, webview.eval and webview.is_visible now return number instead of void. The webview id, request id and visibility flag they hand back can be stored and passed on without a cast.

v0.33.1 - 2026-09-10

Improved

  • The gotchas page now says which absence spelling an engine slot accepts. typescript-gotchas gains a worked passage on passing undefined — never null — to an optional argument, and the Lua-comparison and lifecycle pages point at it rather than leaving the nil collapse to read as permission to pass null.

Fixed

  • 21 engine parameters the reference itself shows being omitted are now optional. The resource texture-creation buffers and the async callback, the gui texture flip, sys.set_engine_throttle's cooldown, the b2d shape/fixture/joint slots and iap.buy's options all rejected the calls their own docs teach, so sys.set_engine_throttle(false) and iap.buy("sword") now compile.
  • msg.url now accepts undefined wherever the engine accepts nil — as the socket of the three-argument form, addressing the current game world, and as the single argument, addressing the current script. The two-argument call stays rejected.

v0.33.0 - 2026-09-08

Breaking

  • Refreshing the bundled library pins changes declarations a project may already be calling.
    • druid breaks two call sites at 1.3.1: text set_text now requires the new text as an argument and returns the component, so a bare text:set_text() no longer compiles, and a button's style is now the typed druid_button_style rather than a plain LuaTable, so a value declared LuaTable no longer assigns to it.
    • decore changes six declarations across 4 -> 6, two of them without a compiler error.
      • event_bus.process_all and the tiny-ecs system.nocache opt-out are gone. process_all folded into process, and nocache went with the shape cache that replaced it; both were call-site-visible, so a project using either must move before taking this release.
      • event_bus.trigger now takes the entity second. A written trigger(name, payload) binds the payload to the entity slot — move it to the third argument. The compiler often will not catch this, because every field of entity is optional.
      • event_bus.process calls back once per entity. The callback takes (entity, data) rather than the event list, and the call returns both the events and their entities.
      • event_bus.set_merge_policy and merge_callbacks re-shaped the merge callback to (entity, data, datas, entity_map). An existing inline callback keeps compiling with every parameter silently re-bound, so read each body rather than trusting a green build.
      • event_bus.get_events and get_stash changed shape. get_events now requires the event name its old declaration wrongly omitted, and get_stash yields unknown elements rather than LuaTable, so using one as a table needs a cast.
      • world.findEntities requires the out buffer. A three-argument call through the world field needs an explicit undefined fourth argument; the module-level find_entities takes the same buffer optionally.
    • event no longer declares promise.cancellation. Upstream marked the field private at 21, so it is hidden from the generated declarations and the /api docs like every other non-public member. Read promise.on_cancel instead: it is the same event object the old field reached through cancellation.on_cancel, now published on the promise itself.
    • log no longer declares get_default_logger_name. Upstream moved it out of the public module at 7, and there is no replacement — the default logger name is now derived internally — so a project calling it must supply its own name to get_logger.

Improved

  • The bundled library pins are being refreshed against their current upstream releases.
    • druid moves from 1.2.5 to 1.3.1, adding get_value/set_value on progress, is_enabled/set_enabled on swipe, set_value on timer, set_justify/is_justify on rich text, add_drag_action/remove_drag_action on drag, refresh on data list and get_text_visual on input. Several existing declarations widened without breaking a call site — get_widget takes an optional template, the druid instance's set_whitelist/set_blacklist made their argument optional, and a button callback now receives the caller, the custom args and the button — while the internal _on_mouse_hover on scroll is gone.
    • decore moves from 4 to 6, adding a remove_component module function, an optional out buffer on find_entities, entity-parallel event-bus storage (event_entities, stash_entities and their getters) and per-phase system lists on world. Event ids now accept a Hash as well as a string, and get_events takes the event name its old declaration wrongly omitted.
    • event moves from 19 to 21, publishing on_cancel directly on a promise so cancellation cleanup no longer reaches through an internal context field. cancel is narrowed to in-progress work — a promise that already settled is left alone, while pending descendants are still rejected and still trigger the shared on_cancel.
    • log moves from 6 to 7, adding a file-output API (set_file, get_file, clear_log_files, final and the per-logger set_file_nearby) and custom log handlers (add_callback, remove_callback, clear_callbacks). The level methods now accept a nil message, and get_default_logger_name is gone.
    • panthera moves from runtime.8 to runtime.10, a purely additive release: the animation state gains the fields the new clip playback path exposes (clips, template_states, play_animation, play_options, play_sample_depth and a reusable collect_buffer), and three supporting types are now declared. Nothing was removed and no existing declaration changed, so no call site moves.
    • bridge moves from v2.0.0 to v2.1.0, adding a notifications API: schedule a notification the platform shows after the player leaves the game, cancel one by id or cancel_all, and is_supported to check the platform first. Nothing was removed and no existing declaration changed.
  • Refreshing library pins is a new guide page for moving a bundled library to a newer upstream release. It gives the regeneration commands per lane — including why the hand-vendored authored lane has no fetch step — and names both what a bump moves with it (the committed fidelity floor, the snapshot digest, the docs-site provenance assertions, the generated docs artifacts) and what it must leave alone, including the consumer test fixtures that pin the very same version string, which is why a repo-wide find-and-replace is unsafe and a green suite is no proof it was done right.

v0.32.1 - 2026-09-06

Fixed

  • The go.property reference no longer teaches the call this toolchain deprecates. Its entry now leads with a warning naming the defineScript({ properties }) field, and its TypeScript example declares the property there. Script properties on self explains what a direct call costs — the property registers at runtime but never reaches self's type, so reading it is a compile error — and shows the before/after migration.

v0.32.0 - 2026-09-05

Breaking

  • The toolchain is now supported on Bun >= 1.4. Every CI and release leg runs that minor and the getting-started floor names it; Bun 1.3 is no longer tested, so upgrade Bun before taking this release.
  • go.get, go.set and go.property no longer name a resource handle nothing hands out. The Opaque<"resource"> member is gone from go.get's and go.set's fallback value union, and go.property's deprecated resource overload with it; since the shipped API never produced that handle, no value you can get out of these declarations loses a call site. A resource brand you declared or asserted by hand no longer satisfies go.set or go.property — pass the Hash the resource.* functions actually return.

Improved

  • Your project's own message ids can now carry a typed payload. Declare them as string keys of the ambient CustomMessages interface and msg.post, isMessage and onMessage check and narrow them exactly like a built-in message, while the emitted Lua stays byte-for-byte what it was. messages carries the recipe, a worked cross-object example, and where a declaration may live — beside the payload type it names, or in a mapping-table .d.ts — along with the two shapes that quietly do not register.

Fixed

  • The camera and sprite property catalogs now report the types the engine really uses. All eight camera.properties members read as unknown, so every go.get<camera.properties>() needed a cast; they are now number, with camera.projection and camera.view typed Matrix4 and sprite.frame_count typed number where the reference data says otherwise.

v0.31.0 - 2026-09-03

Improved

  • build, watch, run, upgrade and bob name a newer Defold release when one exists upstream of your pin. Checked at most once a day against a per-user cache, advisory only, and silent when you are offline; --json carries it as upstreamRelease: { current, latest }, and --no-update-check or DEFOLD_TYPESCRIPT_NO_UPDATE_CHECK turns it off.
  • scene-types addresses now name the object and world they resolve in, cover your libraries, and stay current by themselves.
    • Worlds. A collection opened through a collection proxy is offered as mylevel:/enemy rather than a bare path, and a collection factory's prototype is offered no static address, so the editor stops suggesting paths that resolve in the wrong world.
    • Objects. Component ids are offered object-qualified — /player/player#sprite beside the bare #sprite — so an id is never suggested on an object that does not own it.
    • Libraries. resolve unpacks each dependency's scenes and merges their component ids, object paths and animation ids into your own under the address Defold uses, your file winning a collision. A dependency you declared but have not resolved is now named on the warning channel rather than silently skipped.
    • Freshness. Saving a .collectionproxy, .collectionfactory or game.project regenerates the declaration too, so watch no longer serves the wrong world's addresses until you restart it.
  • The editor completes more of what you type inside a quoted name, and its panel says where each suggestion is valid.
    • Relative addresses. An address slot also offers the forms valid from the file you are editing — sibling ids, deeper sub/id paths and their #fragment joins — while a bare /path is offered only where your own script's world can reach it.
    • model.play_anim. Its anim_id completes from the .animationset the model your sibling url addresses reads from, credited to the set that really lists each entry.
    • gui.play_flipbook. Its animation completes from the textures of the one .gui scene owning your gui script, never a project-wide union.
  • build, watch and your editor flag address literals that cannot resolve, naming the file without failing the build. A #fragment is checked against the components the addressed object really declares (unreachableAddresses), and a socket-qualified address such as mylevel:/enemy written at a slot that resolves in the caller's own world is reported with the world your script actually runs in (crossWorldAddresses). --json repeats both as structured entries, and the editor plugin shows them as suggestions so a broken address squiggles as you type while tsc --noEmit stays clean.

Fixed

  • resolve can no longer be made to write outside .defold-types/dependencies/. A dependency archive entry that traverses out with a .. segment is refused and named on stderr, and the rest of that archive still unpacks; a directory merely starting with dots is an ordinary path.
  • run no longer launches a cached stock engine and a build that record different Defold versions — the pairing that made Defold report FORMAT_ERROR after a pin bump. It now reports the two versions instead of launching; an engine cached before this release keeps launching until one bob run replaces it.

v0.30.0 - 2026-08-30

Improved

  • scene-types turns your project's scenes into completions, and keeps them current on its own. The game-object paths and component ids in every .collection and .go land in .defold-types/scene-addresses.d.ts, which init and upgrade name in your tsconfig.json, build refreshes before it transpiles, and watch refreshes on every scene save — so address slots like msg.post's receiver suggest real addresses while still accepting one composed at runtime, and you run the verb yourself only for a one-off or a CI step that runs neither.

Fixed

  • A pinned Defold target can call the Lua standard library again. The surface written for a pin omitted the lua-types references the package entrypoint carries, so math, string, table, os and bit stopped resolving in your own sources the moment you pinned; both writers now lead the surface's index.d.ts with them.
  • The editor plugin now loads in a real editor. @defold-typescript/tstl-plugin exposed only an ESM entry, which the TypeScript language server loads and then skips for not being a plugin factory — so scene completions, the provenance panel, and the unreachable-#fragment suggestion never appeared outside the test suite; the package now ships a require-shaped entry the plugin loader accepts.
  • watch keeps the scene-address declaration current on a pinned Defold target too. A pinned project wired neither the scene watcher nor the generator, so the declaration was never written at startup and never refreshed when you saved a .go or .collection — an unpinned project already did both.

v0.29.0 - 2026-08-29

Breaking

  • physics.get_shape now types its result as the variant record it is. The declaration listed diameter twice — invalid TypeScript that skipLibCheck hid — and marked every shape-kind field required; diameter, dimensions and height are now optional, so reading one takes a narrow (if (shape.diameter !== undefined)). physics.set_shape takes the same field set and loses its duplicate too.

Improved

  • Converting a project no longer tells you to run init-agents first. init already writes the AGENTS.md / CLAUDE.md agent contract, so Getting started now names init-agents only as the repair for a contract that is missing or has lost its managed block.
  • The guide now says src/ is a default, not a fixed location. Every page that names src/ as where your TypeScript lives carries a footnote pointing at the include globs in tsconfig.json — the scope build and watch actually compile.
  • A typedef in the API reference now has its own heading, and signatures link to it. Each shape a page documents gets a heading of its own in the "On this page" list instead of sharing one Types section, and a parameter or return type naming one of that page's shapes links straight to that shape's heading — including when the shape's name matches an earlier heading on the same page.
  • The API reference version range selector reads at a glance. The closed From / To chrome now shows the bare version behind a direction arrow instead of the word label plus Defold 1.13.0, and the full Defold <semver> label still names every option once the dropdown is open.

Fixed

  • A pinned Defold target now gets the same typed surface as an unpinned project. Every surface the toolchain writes for a pin was missing the hand-authored augmentations — the vmath, go and msg overloads, the message and window-event guards, and the global hash/pprint declarations — along with the built-in message table those guards and overloads are written against, so code that compiled unpinned stopped compiling once you pinned and msg.post payload checking quietly fell back to any.

v0.28.3 - 2026-08-27

Fixed

  • init-agents has its own CLI page, listed with the other verbs: what the managed AGENTS.md block carries, why re-runs never touch your own notes, how it differs from the contract init and upgrade already write, and its --json envelope.
  • A re-run that changes nothing now leaves AGENTS.md alone. init-agents (and init --force) used to rewrite an already-current contract and report it as written; the file keeps its timestamp and the --json written list stays empty.
  • The usage line names every command. Running the CLI with no verb, or an unrecognized one, printed a list that omitted set-target, upgrade, and reload; it now lists them all and points at --help for each command's flags.

v0.28.2 - 2026-08-27

Improved

  • The Defold version can come from the editor you already have open. With this project open in the editor, version resolution asks that editor directly instead of guessing at an install path.
    • set-target --detected — pins the version you are actually running, not whatever a conventional install path happens to hold.
    • Pin-drift notice — compares your pin against that same live version, so build and watch stop reporting drift against an editor you are not using.
    • Nothing open, or an editor gone quiet — unchanged behaviour: detection falls back to reading the editor's config on disk, and an editor that stops answering is abandoned rather than left holding the command.

Fixed

  • set-target --detected finds editors the toolchain would not have guessed, and says where it looked when it still cannot.
    • DEFOLD_TYPESCRIPT_EDITOR — point it at the folder holding the editor's config and it is read ahead of the conventional per-OS locations. This is the answer for a Windows install, which is a portable archive you extract wherever you like.
    • Failure message — a miss now lists every path it read and why, instead of telling you to install the Defold you already have.

v0.28.1 - 2026-08-26

Fixed

  • set-target has its own CLI page — its version and channel tokens, --detected, the rejected-version error, and its --json envelope. The verb that changes the defold-target pin was documented only inside Pinning the Defold target, which now opens by saying what a target selects and the two places you express it: that pin, and the per-run --defold-target flag.

v0.28.0 - 2026-08-25

Improved

  • The API reference can be read over a range of Defold releases, not just one. Paired From/To dropdowns pick the range: every page and index then covers it whole, narrowing From drops the symbols that had already gone by then, and moving either bound keeps you on the page you were reading whenever the new range still covers it. See Reading the API reference over a range.
    • Symbols — a page covers every symbol that existed anywhere in the range, with an availability note naming the release that actually added or removed it.
    • Signatures — a symbol shows the newest declaration made inside the range, or the one it was built with when the range declares none, so a deprecated symbol keeps its full declaration rather than a weaker one.
    • Indexes — a version index now lists everything that version's pages cover, including namespaces removed in an earlier release and the Lua standard library, so it matches /api; both state which releases are tracked and that an unmarked symbol is older than all of them.
    • Badges — the New/Changed/Deprecated markers and every count beside them, sidebar included, now describe movement inside the range you picked rather than across all tracked releases, so a same-release range marks nothing New or Changed while Deprecated still follows the To bound and can mark it. Availability notes stay absolute, and the sidebar counts carry every category the range can reveal and announce the tally they are currently showing.

v0.27.0 - 2026-08-23

Improved

  • Nothing you were already using disappears when something upgrades. A Defold patch release and a toolchain upgrade both used to overwrite the surface they replaced; each now lands beside it. See Pinning the Defold target.
    • Defold targets — the target a patch replaces is demoted to a committed historical surface rather than overwritten, so it keeps resolving through set-target. The toolchain ships the current release plus the previous minor pre-baked, and a bump reports every version that leaves that set.
    • Defold 1.13.0 — a shipped API target again: set-target 1.13.0 resolves, and build materializes its complete pre-baked surface, including its own editor-script API and the /api/defold-1.13.0/… reference pages.
    • Materialized directories — .defold-types/defold-1.13.1@0.27.0/ and .defold-types/libraries@0.27.0/ now name the toolchain that wrote them, and are stamped only once every file has landed. Your tsconfig moves to the new names, and a run cut short reads as incomplete instead of vouching for contents it does not have.
  • Version notes name the release that actually changed a symbol. Across the API reference and its search, compute reads Since Defold 1.13.0 rather than Since Defold 1.13.1.
  • A repeat resolve reuses the library surface when your dependency set and the toolchain are both unchanged, instead of rewriting it.

Fixed

  • A Defold pin now holds, and says so when it cannot. Five ways it used to fail quietly:
    • set-target — a version that never existed, such as 1.42.99, printed a confident transition line and exited 0. The pin is now written only when the API registry can provide the version, and otherwise rejected with the resolvable targets listed, writing nothing either way; --detected is checked identically, and channels still pass through.
    • build, run, watch, upgrade, bob — a pin with no shipped API surface materialized nothing and exited 0 while your code kept compiling against the newer default. They now name the pin and the resolvable targets on stderr and in the --json warnings, and --fail-on-drift turns it into a non-zero exit.
    • Package imports — one idiomatic import { defineScript } from "@defold-typescript/types" merged the current API surface back over the pinned one for every file, so a project pinned to 1.12.4 still compiled collectionproxy.load. A pin now binds the package specifier itself, and still serves the package's complete export set.
    • On-demand generation — the generator's own inputs were left out of the published package, so every target that is generated rather than pre-baked made build --defold-target <version> report could not materialize and quietly keep the default surface. A checkout never saw it.
    • Code examples — a project pinned to 1.13.0 or 1.12.4 saw raw Lua in the @example block of gui.set and six other calls. Every committed surface is now checked, so a Defold bump cannot silently regress one.
  • A matched vendored library's types survive the next build. Once the library surface started naming its toolchain version, the build following a resolve dropped the libraries@<version> entry from your tsconfig.json, so every library symbol stopped resolving until you re-ran resolve.
  • The prefixless globals are on the current Defold surface again. hash, hash_to_hex and pprint read Removed in Defold 1.13.1 across the API reference and its search, and the 1.13.1 version index rendered no Globals section.

v0.26.0 - 2026-08-20

Breaking

  • The pinned Defold target is now 1.13.1, and 1.13.0 is gone. A patch release replaces its predecessor rather than sitting beside it, so defold-1.13.0 is no longer a shipped API surface: --defold-target 1.13.0 stops resolving and the /api/defold-1.13.0/… reference pages are retired. Move the pin to 1.13.1 — a project already on 1.13.0 needs no source migration, and a project on 1.12.4 still migrates through the 1.13.0 notes, which stay under their own heading. See Pinning the Defold target.
  • The per-version upgrade page is now one evergreen guide. Upgrading Defold versions replaces upgrading-to-defold-1-13-0.md with a version-agnostic runbook plus one ## Defold <version> section per release, each keeping that release's own "what changed" notes, so the old page's URL no longer resolves. Each release's per-symbol notes are individually linkable headings and appear in the page's table of contents.

Improved

  • Defold 1.13.1 brings two Lua API changes, both additive — nothing was removed or deprecated:
    • collectionproxy.load — loads and initializes a proxied collection, with the callback receiving proxy_loading, proxy_ready and proxy_error.
    • gui.set — its value parameter now accepts nil, so a property can be cleared rather than only reassigned; existing calls are unaffected.
  • A version note on an API reference page now names the version that changed the symbol, and reads before the description instead of after it. A symbol absent from the newest surface says Removed in Defold 1.13.1 rather than Available through Defold 1.12.4, and one whose name survives under a new signature — gui.set, whose value now accepts nil — says Signature changed in Defold 1.13.1 instead of claiming it is gone.
  • Editor scripts gain the editor VM's image library — image.load_file, then image.size, image.pixel and the image.pixels iterator over the loaded image.

v0.25.0 - 2026-08-18

Breaking

  • starly is no longer part of the library corpus: its types, its reference page and its entry in the resolvable set are gone. The library was withdrawn upstream — its repository and its author's account were both deleted, it never published a release, and the only surviving copy is an unaffiliated third-party mirror — so no one can obtain a runtime for the declarations. For a 2D camera, use shutter, added this release as the closest replacement, or the longer-standing orthographic and rendy.

Improved

  • The CLI now works with the running editor. A reload does not re-run init, so whatever it set up belongs in on_reload, and Defold's own build errors still reach only the editor's Build Errors tab.
    • watch --hot-reload — scaffolded as the defold-typescript:watch-hr mise task, it pushes every successful rebuild into the running game, reloading nothing when a build fails, reloading the editor's extensions instead when the emit was an editor script, and naming the editor in your terminal when a reload is refused, after which it stops reporting that editor as attached until a reload actually lands; with or without that flag, watch prints the running game's runtime errors and warnings with their tracebacks into your terminal, and stopping it goes quiet at once — the console stream closes, a reload already on the wire is cancelled rather than left outstanding, and nothing further is reported: not a reload still waiting to attach, not the later commands of a reload that pushes more than one, and not a game.project re-resolve that finishes after the stop. build names the editor it found under a timeout, so a stale port file pointing at a process that never answers is treated as no editor at all instead of holding the build.
    • reload — a one-shot counterpart for scripts and agents: it pushes a single reload into the running game — or the editor's own extensions with --extensions — then reads the editor console for a bounded window (--wait, default 2s), exiting non-zero when the reloaded code throws, when the editor refuses, and when a requested window could not be opened at all; a stale editor port ends the command on a deadline instead of parking it. Exit 0 claims only that the post was accepted — plus a quiet console when a window was read, and nothing more under --wait 0, which opts out of the read entirely — and --json reports which of the two happened as consoleObserved.
    • Console errors name your TypeScript — on both surfaces a reported location now carries the authored .ts line and column in front of the generated chunk one (src/main.ts:5:11 (/src/main.ts.script:4)), read from the source map the build writes beside every output and naming the file you edit under any layout, including a project that builds into an outDir, on the first build and on every rebuild alike. It is best-effort and never invents a location: a chunk with no usable map, a generated line the map does not cover, and a map resolving to anything that is not a file in your project are all left exactly as the console sent them, while under reload --json the raw consoleErrors stay unchanged and the translations arrive beside them as consoleErrorLocations.
  • Editor scripts get a typed editor API. The new @defold-typescript/types/editor-script entrypoint exports the defineEditorScript and defineEditorCommand factories — both erasing to plain tables the editor can load — and carries the editor VM without the game runtime: editor.get/bob/execute/transact/tx.*, the editor.ui.* dialog toolkit and editor.prefs.* (its schema group and the COLOR/SCOPE-style constant tables included, with every builder returning one nominal component handle editor.ui.show_dialog accepts), the VM's own http, json, zip, zlib, pprint, localization and tilemap.tiles libraries with every call shape Defold documents accepted as written (zip.pack(archive, ["build"]), a two-argument http.server.route) and json.decode/json.encode returning real values rather than nothing, and a command's active/run opts bag typed from its own query, so a "one" selection reads as a single node, a "many" one as a list, and a member the query never declared is a compile error. wall now offers a directory holding only editor scripts as a target like any other kind, so you no longer set types by hand.
  • Walled directories follow your pinned Defold target. A pinned surface now carries the editor-scripting API of the target that declares one, and a wall narrowed to a pinned kind resolves both its ambient namespaces and its @defold-typescript/types/<kind> factory import from that one surface — a target declaring no editor-script document of its own keeps the installed entrypoint, and a wall never narrows to a kind its surface did not write. That redirect is the only module mapping a wall manages and resolves against whatever baseUrl your root tsconfig.json declares — absolute ones included — so the aliases your root and the wall's own config declare keep resolving inside a walled directory, and dropping the pin leaves them untouched.
  • New libraries in the corpus, each maintained here against its pinned upstream and materialized by resolve once you declare the dependency:
    • shutter (Klaleus/defold-shutter) — a 2D camera covering the ground starly's withdrawal left open: the camera table, the three viewport behaviors, the screen/world conversions and the shake helpers.
    • nakama.socket and nakama.session (heroiclabs/nakama-defold, pin v3.4.0) — the realtime socket's chat, match, matchmaking, party and status calls, each also bound onto the socket instance create returns, plus the helpers that build, check, store and restore a session. match_create takes a nil name to let the server generate one and match_join takes either a match id or a matchmaker token, so unnamed creation and token-only joins type-check; the v0.24.0 note that a socket binding needed vendoring of your own no longer applies.
    • checkpoint (Klaleus/defold-checkpoint) — the successor to the abandoned persist, typed for reading and writing save files as JSON or binary. It needs britzl/defold-lfs at runtime, which this corpus does not type.
  • The editor completes what your project declares. In an editor running the transpile-diagnostics plugin, the suggestions are listed after everything the editor already offers, nothing it offers is removed, and a caret inside a hash("…") completes the slot the call around it occupies one level out, so the hashed form offers what the bare literal does while a doubled hash(hash("…")) offers nothing. They are read from an index the plugin holds across requests and refreshes whenever a file it reads changes, so completing repeatedly in one slot no longer re-walks your project and a newly authored id is offered without restarting the editor.
    • Game-object paths and component ids — inside an address argument the caret picks the half: from the # onward you get the component ids your project's .go and .collection files declare, replacing the #fragment only, and anywhere before it — including a literal carrying no # yet — you get the game-object paths those files compose, replacing the path half alone. A collection instanced inside another prefixes every path it holds (/player/player, never a bare /player), while a children: edge is a transform relation and adds no segment.
    • Node ids — a caret inside gui.get_node's argument offers the node ids of the one .gui scene that owns the script you are editing, replacing the whole quoted name; ownership is resolved through the same outDir and include rules the build uses, so a project with a separate output tree completes too. A script no scene owns, or one that two scenes both claim, offers nothing.
    • Animation ids — a caret inside sprite.play_flipbook's id argument offers the animations declared by the atlas of the sprite the sibling argument addresses, again replacing the whole quoted name. The address must be the same-object "#id" literal: a path form, a variable or a msg.url(…) call names a component this file cannot decide, so nothing is offered.
    • Resource paths — a caret inside one of the six resource property constructors (atlas, buffer, font, material, texture, tile_source) offers the project's own files of the one kind that constructor accepts, as the /-prefixed paths Defold resolves. build/ output and the directories init's .defignore names (node_modules, .defold-types, .vscode) are left out, as are the built-path slots and the extension-less loaders.
    • Config keys — a caret inside the key argument of sys.get_config_string, sys.get_config_int, sys.get_config_number or sys.get_config_boolean offers the SECTION.KEY ids your project's own game.project declares, replacing the whole quoted text. Only what that file writes is offered — a key it omits answers the reader's default at runtime — and a project without one offers nothing.
    • Action ids — a caret inside a hash("…") compared against your handler's action_id (action_id === hash(""), either operand order, defineScript's on_input method included) offers the actions every .input_binding in your project declares, replacing the whole quoted text. The comparison is what scopes it — a hash("…") carrying none, the hoisted const JUMP = hash("jump") form included, offers nothing — and the slot is Defold's own ambient hash, so a hash your project declares or imports itself is never offered ids.
    • Where a suggestion came from — highlighting one of these suggestions names the project files that declare it, every kind covered: the .go for a component id, the collection declaring a game-object path's leaf segment, the .atlas or .tilesource an animation id was read from, the owning .gui for a node id, game.project for a config key, every .input_binding that declares an action. Inside an address the panel follows the caret's half exactly as the suggestions do, and anything the project cannot attribute exactly — a scene that failed to parse, a script two game objects both claim — keeps your editor's own panel rather than a guessed one.
  • Address slots say what they address. The 27 URL parameters that name a scene object — go's id/url slots, msg's receiver and urlstring — read SceneGameObjectAddress, SceneComponentAddress or SceneAddress instead of string, so the reference distinguishes a game-object path from a component one. The aliases accept every string, so nothing that compiles today stops compiling.
  • A hashed name remembers the string it came from. hash("#sprite") now reads as Hash<"#sprite"> rather than a bare Hash, so the idiomatic const SPRITE = hash("#sprite") still says which component it addresses. The parameter defaults to string and constrains nothing, so every existing Hash annotation and every call — hash("jump"), go.set("#sprite", hash("tint"), v) — compiles unchanged.

Fixed

  • run hands the engine every argument after --, including ones sharing a name with a CLI flag. run . -- --json now launches the engine with --json instead of consuming it and switching the CLI's own output into JSON mode.
  • Keys you add to a managed mise.toml task now survive init and upgrade, wherever in the task you wrote them and however TOML lets you spell the key — after a blank line, below a hand-edited multi-line run, or written as env . CONFIG, env."MY VAR" or an escaped "run" — and tables of your own, with whatever their values happen to contain, stay tables of your own. A refresh used to replace each defold-typescript:* block wholesale, end it at the first blank line, and judge a key by its raw spelling, so an alias, a depends or a comment was dropped or hoisted into the root table and an escaped key was duplicated or quietly deleted, in the worst case leaving a mise.toml that mise refused to parse at all; a block now ends where its TOML table does, and only the keys that really mean description and run are rewritten.
  • A walled directory under a pinned surface no longer type-checks against the installed release's API alongside the pinned one. The @defold-typescript/types/<kind> factory import used to resolve through node_modules to the installed package, so the program saw the union of both surfaces and a call the pinned release does not declare compiled anyway; it is now the compile error it should always have been.
  • Reference-site corrections, each on what a page displayed rather than on what it documents:
    • Libraries index — no longer credits the ts-defold/library project for its type definitions. Every library has been maintained in this repo since v0.24.0, generated from upstream sources that ship machine-readable types or hand-forked where upstream ships none.
    • persist and rendy — credited to their author's current GitHub account, so the attribution links no longer depend on a rename redirect.
    • boom and deftest — the reference pages now show the type parameter their generic helpers take, instead of a signature naming a T it never declares.
    • Migrating from ts-defold — the command surface it lists names every verb again, including upgrade, set-target, reload and run, along with bob's full subcommand set.

v0.24.0 - 2026-08-08

Breaking

  • Library surfaces corrected against their upstream pins, so code written to the old shapes stops type-checking until it is updated.
    • defmath — in_triangle takes (x0, y0, arr) with a six-number array instead of eight loose coordinates.
    • defsave — save and set return boolean | undefined instead of void, and load narrows from unknown to the same.
    • druid — the drag callback declares the six parameters the runtime really passes, (self, dx, dy, x, y, touch), so a handler that read touch out of the second argument needs its parameter list updated; and layout.on_size_changed.subscribe takes the inherited event signature subscribe(callback, context?), so drop any leading placeholder argument.
    • gooey — the three dynamic-list calls drop a root_id argument upstream never took, dynamic_list and static_list drop a trailing is_horizontal, and vertical_scrollbar gains upstream's config before its callback — so old calls were passing arguments into the wrong slots.
    • metrics — create's position and color are a Vector3 and a Vector4 instead of string; pass vmath values, or the module's own POSITION/COLOR defaults.
    • monarch.transitions.easings — create is gone, since upstream keeps it private; call the per-easing BACK(), BOUNCE(), CIRC() wrappers instead.
    • nakama — every request-taking call declares upstream's positional parameters instead of a body object, and all 84 retry-capable calls accept a trailing retry_policy and cancellation_token. The socket surface is gone from this module, which never exported it — create_socket is the one door it opens to a separately vendored nakama.socket.
    • nakama.engine.defold — http takes retry_policy and cancellation_token before its callback, and socket_send drops its third argument.
    • orthographic — add_projector, get_projection_id, use_projector and the constants MSG_USE_PROJECTION and ORTHOGRAPHIC_RENDER_SCRIPT_USED are gone; upstream defines none of them, so each already failed or read nil at runtime. world_to_screen drops its third adjust_mode argument, which upstream silently ignored.
    • rendy — animate and cancel_animations are gone; use go.animate and go.cancel_animations directly.
    • yagames — the five banner_* calls give way to the sticky-banner API upstream documents (adv_show_banner_adv, adv_hide_banner_adv, adv_get_banner_adv_status), the four sitelock functions are gone because the module never exported them, and payments_get_catalog takes upstream's (options, callback).
  • wall judges a directory by its whole subtree rather than only the sources it directly holds, so a directory whose subdirectories add another kind is no longer eligible. Wall the single-kind directories beneath it instead.

Improved

  • Every library's types are now maintained in this repo, forked from upstream where no usable structured source exists: declare the dependency and resolve materializes them. Imports and type surfaces carry over unchanged except as noted here.
    • Reference pages moved — a single-module library now lives at its bare namespace: /api/nakama, /api/persist, /api/yagames, /api/gooey, /api/bzAnim, /api/platypus, /api/dicebag and /api/rendy. bzAnim's documented import becomes import * as bzAnim, over the same "bzAnim.bzLibrary" path.
    • defsave — the previous binding declared about half the module, so the fork adds seven functions (obfuscate, get_file_path, key_exists, isset, reset_to_default, is_loaded, final), the config fields, and save's force argument.
    • boom — the pin moves off the 1.0.0 tag, which predates the camera helpers to_screen and to_world; both are declared now.
    • orthographic — camera.follow accepts an array of game objects as well as a single one, and get_view and get_projection return Matrix4 instead of unknown.
    • metrics — both modules gain the module-level update(), draw() and fps()/mem() calls upstream defines over its built-in singleton, so you can read the FPS or memory figure without creating an instance.
    • gooey — gooey.group takes the action_id and action arguments the runtime requires, so the four-argument call every upstream example writes finally type-checks.
    • yagames — player_get_id keeps a correctly spelled pointer to player_get_unique_id, and leaderboards_init is marked deprecated as upstream marks it.
    • monarch — upstream's README documents the focus listener as on_focus_change; the function the runtime defines, and the one these types bind, is on_focus_changed.
  • panthera (Insality/panthera) joins the corpus: declare the dependency and resolve materializes a typed panthera.panthera covering create_go/create_gui/create, play/play_tweener and the animation-state shape. defold-tweener is a runtime companion only — panthera's types resolve without it.
  • Every forked library is measured against its own upstream Lua on two separately ratcheted axes, functions and constants, so one nobody has checked can no longer read as clean: 35 of the 35 modules now cover their upstream's whole surface on both. Generated libraries carry a committed coverage floor too, so regenerating one can no longer quietly type less of it than before.
  • More of each generated library's surface carries a real type where it previously fell back to unknown.
    • Callback parameters — arguments documented only as function in event, lang and druid are callable types, so you can pass a typed function literal and call the value back without a cast.
    • Nullable unions — values documented as a union with nil, such as bridge's platform.id and player.name, type as string | undefined, so a null check is enough.
    • druid — druid.button's six style hooks and druid.drag's init callback name their real parameter types, druid.layout's rows is a druid_layout_row_data[], and a multi-return call such as druid.layout.get_content_size returns a LuaMultiReturn tuple. Component callback fields like on_click and on_hover are event objects you can subscribe to — declare defold-event alongside druid so the type resolves.
    • log — get_default_logger_name takes the real debug.getinfo() table, so reading short_src off it type-checks.
    • decore — ecs.world returns a rest tuple you can spread instead of a fixed pair whose second slot was a single anonymous unknown.
  • A library's API reference page shows more of what its types actually say.
    • Constants and briefs — a forked library's page documents constants as well as functions: 61 constants gained the description their fork already carried, eleven members were written up in the fork's own words, and 254 members across 14 libraries fall back to upstream's prose under a U dot marking it as borrowed.
    • Options shapes — an options object documents its fields instead of rendering as a bare type name — 29 shapes across five libraries, including monarch's ShowOptions and gooey's ButtonState. Optional fields are marked ?, so an all-optional table no longer reads as all-required.
    • Deprecations — an upstream @deprecated marker shows as a Deprecated line carrying its explanation, in the same block the engine pages use. A tag on a type rather than a member reaches the shipped .d.ts, where your editor strikes the name through, but not the page.
    • Ambient globals — a library declaring most of its surface outside its module block finally documents it: boom goes from 1 symbol to 112 and deftest from 2 to 32. Each is marked G, and the page's import step notes they are callable without the import.
  • The Libraries tree is organized by GitHub origin: a library nests under its owner and the repo you actually install (britzl/defold-input, not britzl/in), a repo publishing a single module collapses to one row, and every row spells its owner/repo/namespace path out on hover. The maintained-here pin is gone — every library is maintained here now, so it distinguished nothing.
  • wall understands nested walls, so you declare one at the boundary you actually mean instead of at every leaf.
    • Inheritance — a wall on a parent directory that holds no sources of its own narrows every directory beneath it, including subdirectories added later.
    • Override — a nested wall fully replaces the one it sits inside, instead of leaving its files in the outer program where gui.* could type-check inside a script wall.
    • Provenance — wall --list --json reports every narrowed directory with origin (declared or inherited) and the declaredIn ancestor that caused it; the plain --list line names the inherited pairs.
  • A new --fail-on-drift flag turns the installed-editor-vs-pin drift notice into a non-zero exit on build, watch, run, upgrade and bob build/bundle/run, so CI stops passing on a warning nobody reads. The notice text and --json payload are unchanged, and a command that already failed keeps its own exit code.
  • The agent runbooks warn that the script lifecycle factory needs a value import — the import type plus declare const form builds ok: true while leaving the hooks unerased — and route Defold's resulting FORMAT_ERROR resource cascade back to that fix.

Fixed

  • Forked libraries declare members their upstream really defines that the previous bindings left out.
    • yagames — 22 members covering whole feature areas: the events API, the multiplayer-sessions trio, the five features_* calls, five player_* getters, the shortcut-prompt pair, flags_get, is_available_method, server_time and device_info_is_tv.
    • nakama — 16 members: the subscriptions area, the cancellation pair cancellation_token and cancel, plus delete_account and delete_tournament_record. Its 12 enum constants are declared too, typed as their literal values so op === nakama.APIOPERATOR_BEST narrows.
    • gooey — is_enabled, acquire_input, release_input, create_theme, mask_text, radiogroup, horizontal_scrollbar and set_focus.
    • monarch — the seven live message hashes (TRANSITION_*, FOCUS_GAINED, FOCUS_LOST) and register, upstream's alias of register_proxy. The grouped TRANSITION and FOCUS objects offered instead are now marked deprecated, as upstream marks them.
    • monarch.transitions.gui — the twelve transitions are declared as functions rather than constants of an opaque callable type, so the page documents each one's arguments.
    • orthographic — get_automatic_zoom and set_automatic_zoom, plus the MSG_SET_AUTOMATIC_ZOOM message that does the same by post.
    • rendy — cameras plus display_width, display_height, window_width and window_height. Upstream advises against manipulating these directly, which each one's doc-comment now says.
    • metrics — both modules expose the drawing defaults POSITION, COLOR and FORMAT, used for any create argument you omit.
    • dicebag — bags and tables, the keyed state every bag_create/table_create writes into and every draw reads back.
    • defcon — register_module takes upstream's optional second name argument, and the module exposes print, pprint and server.
    • platypus — SEPARATION_RAYS and SEPARATION_SHAPES, the two values for collisions.separation.
    • bzAnim — setMaxPoints, registerController and unregisterController.
    • richtext.color — parse, parse_hex and parse_decimal; nakama.util.log — custom and format; persist — exists.
  • A dependency that ships modules across two of this repo's registry lanes now resolves and materializes every module; resolve previously kept only the first lane's module and silently dropped the rest.
  • The explicit type-argument factory form the script lifecycle guide documents — export default defineGuiScript<MenuSelf>({ … }) — builds to its component file (src/menu.ts.gui_script) instead of falling through to a plain .lua module of the wrong kind, and a type-only name imported alongside the factory (import { defineGuiScript, type Hash }) no longer fails the build with an unresolvable require. The scaffolded agent contract matches: both self-typing forms work.
  • go and msg document the overloads the toolchain actually ships, each row carrying the description and parameter table its own call shape takes: go.get and go.set lead with their curried property-key generic, go.property lists its eight typed forms, msg.post its two and msg.url its three. The committed llms-full.txt carries the same forms.
  • TypeScript vs Lua no longer suggests a sufficiently pure npm package can work, and TypeScript gotchas gains an entry with the exact build failure, why node_modules is never read, and how to vendor the source under src/ instead.
  • A library whose types are generated from its README reads an argument bracketed across a comma (data [, overwrite]) or through an escaped bracket (duration \[, scaler]) as optional rather than required, and marks every argument inside a multi-argument group optional.
  • A library reference page with a dotted namespace, such as monarch.transitions.easings, titles itself britzl/monarch/monarch.transitions.easings again — matching its Libraries card — instead of repeating the namespace twice with the author dropped, and its heading wraps at the dots rather than scrolling the page sideways.
  • narrator's Story.observe callback parameter is named value, after the argument the library actually passes it.
  • A documentation source can no longer replace a library's existing types with a weaker surface: a source documenting no parameter or return types, one whose comparison surface was truncated, and one hidden behind a single exported handle were all scoring as clean matches. persist and yagames keep the types they had.

v0.23.0 - 2026-07-27

Breaking

  • More libraries' types are now maintained in this repo — each regenerated from its upstream source through the shared LuaLS / ref-doc pipeline (as with druid and decore) and marked with the maintained-here pin in the docs; each surface now follows upstream, so it differs from the previous hand-written binding.
    • tweener (Insality/defold-tweener, tag 6) — per-easing helpers are no longer module-level constants.
    • bridge.bridge (Playgama/bridge-defold, v2.0.0) — regenerated from its committed .script_api as an importable declare module.
    • event (Insality/defold-event, tag 19) — the former untyped any passthrough now carries real types (event.create, subscribe/trigger, promise and queue instances).
    • lang (Insality/defold-lang, tag 5) — the twelve typed functions are tightened, and load_langs, the state getters, and typed lang.data/lang.state are added.
    • log (Insality/defold-log, tag 6) — get_logger's name argument is now optional and its forced-level argument a plain string, and the logger's level methods now require their data argument.
    • proto (Insality/defold-proto, tag 1) — get/decode/verify return the native LuaTable, set_logger takes a typed proto_logger, and the full encoding API is surfaced.
    • saver.saver and saver.storage (Insality/defold-saver, tag 8) — init, save_game_state, get_save_path, and set_logger take their typed optional arguments and the full save and key-value storage APIs are surfaced.
    • immutable (paweljarosz/lua-immutable, tag v1.1) — make returns the typed Immutable interface rather than a generic Readonly<T>.
    • squid (paweljarosz/squid, tag 1.2) — the previous binding typed only save_logs/get_config().is_enabled; the surface now exports the module log-level constants and logging API, a typed get_config/SquidConfig, and a typed SquidInstance from new().
    • narrator (astrochili/narrator, tag 1.8) — replaces the hand-written passthrough with the upstream parser plus the Narrator.Story runtime API, made runtime-faithful: parse_content takes its inclusions argument optionally, continue() returns a single paragraph or an array of them, and the internal Object/constructor tables no longer leak into the surface.

Improved

  • The editor-scripting authoring path is now documented: a Core-concepts guide page walks through defineEditorScript, the <name>.ts.editor_script artifact, and the editor's auto-load discovery, with a worked custom-command example.
  • LuaLS library types (druid, decore, tweener, event, lang) now emit every nil-bearing trailing argument — both T | nil unions and type-suffix T? params — as optional, and nilable interface fields (function | nil, string?) as omittable object properties. Faithful upstream calls like event.create(), instance.subscribe(cb), lang.set_lang("en"), lang.set_next_lang(), and lang.init([{ id, path }]) now type-check instead of demanding an explicit undefined, and object literals may drop fields like loader they faithfully omit. Event and promise instances are also callable now (instance(payload)), matching their runtime __call.

Fixed

  • Installed packages can now resolve the bridge.bridge library again — its script_api resolve manifest was missing from the published tarball, so the resolve command silently dropped bridge on a real install.
  • A script_api library whose types reference engine handles (Hash, Vector3, Url, ...) now emits an importable declare module instead of a broken module augmentation, so import { ... } from "<library>" resolves instead of failing with TS2307.
  • LuaLS library types (druid, event, log, tweener) no longer leak non-public members: fields and methods marked @private/@protected/@package (and methods marked @local) are hidden from the generated declarations, the /api docs, and the fidelity report alike, so the three surfaces describe one identical public set. For example the log logger drops _last_gc_memory/_last_message_time/format/log, and druid components drop the base's protected lifecycle hooks and get_uid.
  • A dependency that ships several modules from one repository (for example defold-saver's saver and storage) is now fully handled: the resolve command materializes every module instead of keeping only the first, and the docs-site Libraries navigation groups them into a single entry instead of one per module.
  • The LuaLS front-end now reliably infers a constructor's return type and instance methods when the function-local class declares extra locals, and a stale ---@type fun(...) method annotation no longer attaches across intervening lines to a later member key — a latent mis-emit fixed before any maintained library shipped it.

v0.22.0 - 2026-07-24

Added

  • Editor scripts are now recognized and built: a source that does export default defineEditorScript({ get_commands, ... }) compiles to a <name>.ts.editor_script returning the hooks table the Defold editor loads — mixing an EditorCommand type import with the factory erases cleanly (no stray require), and editor-only directories are never offered as per-kind type walls. The typed editor.* API and project scaffolding land in follow-ups.

Improved

  • The repo-maintained-library marker in the API reference is now green and easier to spot: in the sidebar it sits on each library namespace leaf instead of the parent folder row, and it also appears on the /libraries index cards.

Fixes

  • init now scaffolds the .gitattributes the Defold editor emits (linguist overrides for correct GitHub rendering and language stats) and ignores Windows Thumbs.db alongside .DS_Store. Both merge into existing files on upgrade, so an editor-created project gains only what it was missing.
  • init now writes a .defignore so the Defold editor and bob skip node_modules, .defold-types, and .vscode when scanning for resources. It merges into an existing file, keeping any lines you added.

v0.21.1 - 2026-07-21

Improved

  • The upgrade guide page is now a CLI verb page (toc-title: upgrade, # Upgrade) sitting in the CLI sidebar subgroup right after init.

Fixes

  • Applied Biome's current formatting rule to inline type literals in the guide-docs test, clearing the lint gate after a formatter-rule update.

v0.21.0 - 2026-07-20

Added

  • Typed bindings for LuaLS-annotated pure-Lua libraries. defold-typescript resolve now materializes generated .d.ts for libraries such as:
    • Druid
    • Decore (first two libraries to proof concept)

    Dependencies — generics, inheritance, variadics, and multi-returns preserved — each with a rendered API page at /api/<name>, and the new Authoring LuaLS library types guide covers adding further libraries as a config-only change, including how to fill an empty API-page description.

  • Library reference pages and the sidebar Libraries tree both show a map-pin marker beside libraries whose type bindings this repo maintains (Druid, Decore), with a hover hint, so you can tell them apart from vendored libraries at a glance.

v0.20.8 - 2026-07-19

Added

  • In progress: typed bindings for LuaLS-annotated pure-Lua libraries (starting with Druid). The plumbing is landing release by release — source ingest and the LuaLS-to-TypeScript type mapper are in place, with the mapper now emitting valid TypeScript for vararg parameters and function return unions; the generated library .d.ts you import ships in a later release.

v0.20.7 - 2026-07-18

Added

  • Guide pages for the run and bob commands, covering the launch/build workflow, the two run resolver errors, the bob.jar cache, and the per-subcommand --json shapes.
  • A pre-commit gate that fails any commit not staging a change to this changelog, so it can no longer drift behind the work that lands; bypass a genuine exception with git commit --no-verify.

Fixed

  • bob status now honors the --java / DEFOLD_JAVA override, matching executing Bob commands, so the preflight reports the same Java runtime a build will actually use.

v0.20.6 - 2026-07-18

Fixed

  • Cutting a release now refreshes the published /changelog on its own: the new tag's date replaces - Unreleased for the shipped version without a manual docs redeploy.

v0.20.5 - 2026-07-18

Improved

  • The installed-editor pin-drift notice now covers watch, run, bob, and the update alias, warning when the editor you have open drifts from the project's version pin.

Fixed

  • run derives its project directory from the arguments before --, so pin drift is no longer read from a <cwd>/-- path.

v0.20.4 - 2026-07-17

Improved

  • Defold-pin drift checks are unified under a single verify-docs-drift mise task, with the drift-root split from the evidence-root so staleness is the sole trigger.
  • Release-smoke overrides derive from the CLI manifest, with a pinned TypeScript.

v0.20.3 - 2026-07-16

Added

  • bump:defold orchestration command for Defold version bumps, including an offline --check release-evidence gate.
  • regen:all aggregate regeneration command.
  • set-target verb to write the defold-target pin.
  • A docs-site color-token parity drift guard.

Improved

  • --defold-target now notifies when it overrides a live package.json pin, and points the override notice at set-target.
  • resolve prunes orphaned extension version-pins.

v0.20.2 - 2026-07-14

Fixed

  • Opaque signature deep-link hrefs now respect the deploy base path.

v0.20.x

The API reference moved to a combined, multi-version surface and the upgrade verb landed.

Breaking

  • The /api route domain is inverted: the combined multi-version surface now owns the canonical /api, each tracked version gets an explicit /api/defold-<version> family, and the previous /api/combined/* routes are noindex compatibility redirects.

Added

  • upgrade verb (with update as a synonym): resolve the latest toolchain, then hand off to the newer CLI or re-scaffold in process, captured under --json. A new upgrading guide documents it.
  • Combined union API surface with an N-version availability model, a version selector, a declaration-backed api-signatures artifact, and combined-only availability badges.
  • Defold 1.13.0 type surface promoted, with a deterministic release importer, an offline release-readiness gate, a 1.13.0 upgrade guide, and catalogued 1.13.0 deprecations (camera-focus messages, reset_constant) surfaced via @deprecated.
  • --help / -h, top-level and per command.

Fixed

  • nil-bearing engine returns are typed as T | undefined, and the nil-return truthiness guidance is corrected to ~= nil.
  • Every promise derived from a captured spawn settles, so an unspawnable child leaves no orphaned rejection.

v0.19.x

Added

  • init writes the agent contract (AGENTS.md), re-syncing an existing one only under --force.

Improved

  • llms-full.txt inlines guide bodies with web chrome stripped and headings nested under ## Guide.
  • Scaffold commands survive a broken toolchain via lazy-loaded transpiler dispatch verbs.

Fixed

  • Refuse to re-release a commit that already carries a release tag.
  • Pin typescript@6.0.2 in the scaffold and cap the tstl-plugin peer below the TS7 native port.

v0.18.x

Added

  • Vendored native and pure-Lua library types materialized into .defold-types during resolve, with /api docs pages grouped by author, a Libraries nav tab, and a live-fetch drift gate; the library-types package is published.
  • Covariant vmath functions typed with generics, so same-type-in yields same-type-out.

Improved

  • init merges into an existing tsconfig.json instead of clobbering it and reports per-file operations.
  • watch stays alive through startup compile errors with located highlighting, and build failures surface located, one-per-error source positions.

Fixed

  • init never excludes src/main.ts and self-heals a tool-added exclude on merge.
  • The CLI node-runtime spawn crash; Java resolution falls back to the editor's bundled JDK when running bob.

v0.17.x

Added

  • More vendored library types (persistence, text and narrative, platypus, defold-event, input, monarch), a pure-Lua classification manifest, and a library-types drift gate.
  • types.is_* checks emitted as user-defined type guards.

Improved

  • The API overview replaced tables with cards, then a linked signature list.
  • Lua type() return tightened to its closed string union.

Fixed

  • Upgraded the GitHub Pages deploy actions off deprecated Node 20.
  • Long space-less inline code wraps on narrow screens instead of scrolling.

v0.16.x

Added

  • Canonical JSDoc for the six core value types, a typed-messages guide page, a previous/next pager on every article, and shiki line-highlighting plus [!MORE] tap-to-reveal disclosures in the Tetris tutorial.

Improved

  • The Tetris tutorial is inverted into inline walkthroughs with the full script collapsed into a disclosure.
  • Global-type docs render as markdown from their JSDoc.

Fixed

  • The scaffold declares a direct lua-types devDependency so Lua stdlib globals resolve.
  • Scaffold .gitignore lines match Defold's canonical /build and /.internal form.

v0.15.x

Improved

  • Several mise tasks ported to shell-free Bun scripts (release-pack-proof, current-version, dev:slides).
  • init --force migrates a deprecated biome.json to the preset.

Fixed

  • Tetris tutorial file-create and scene-wiring steps, plus a window-size step so the board centers.
  • ScriptPropertiesOf exported from the barrel.

v0.14.x

Improved

  • The docs renderer supports same-line GitHub alert markers, and wide tables scroll.

Fixed

  • Migrated biome.json off deprecated recommended to the preset (Biome 2.5.1).

v0.13.x

Added

  • The Build Tetris tutorial guide page and its runnable example under docs/examples, code-block filename chips from a title= fence, and a loadable scaffolded game.project with a [bootstrap] collection and input binding.

Improved

  • The scaffold no longer enforces noDoubleEquals; === and == compile to identical Lua, and the guidance is reframed accordingly.

v0.12.x

Improved

  • Data-structures guide: Lua table extensions documented, LinkedList dropped.

Fixed

  • sourceMappingURL is kept as the generated file's last line.
  • Full builds prune kind-switch outputs and warn on sourceless orphans.

v0.11.x

Breaking

  • npm publishing moved to CI OIDC trusted publishing; local bun-publish is retired.

Added

  • The docs API version selector, with per-version /api routes and search indexes, global value-type reference pages, the offline llms.txt knowledge pack, and topical Defold-way agent runbooks.
  • Signature override stores for the Lua standard library (string, table, os, math, io, socket, and the rest), with an AST drift guard.

Improved

  • Releases require CI green before publish.
  • A responsive docs-site topbar and a collapsible sidebar drawer.

Fixed

  • A Windows separator leak in the client graph.
  • GitHub-compatible heading slugs so in-page anchors resolve.

v0.10.x

Added

  • A top-of-page function summary table on /api pages.
  • A presence-parity gate enumerating ts-defold-types-only symbols.
  • Socket handle methods emitted as receiver interfaces.

Improved

  • Lifecycle-hook and InputAction / InputTouch members documented with fixture-pinned JSDoc.

On this page

v0.68.0 - 2026-11-20ImprovedFixedv0.67.0 - 2026-11-18ImprovedFixedv0.66.0 - 2026-11-15BreakingAddedImprovedFixedv0.65.0 - 2026-11-13ImprovedFixedv0.64.0 - 2026-11-12BreakingFixedv0.63.0 - 2026-11-12BreakingAddedFixedv0.62.0 - 2026-11-10BreakingImprovedv0.61.1 - 2026-11-10Fixedv0.61.0 - 2026-11-10BreakingImprovedFixedv0.60.0 - 2026-11-09BreakingImprovedFixedv0.59.0 - 2026-11-07Improvedv0.58.0 - 2026-11-06BreakingImprovedFixedv0.57.0 - 2026-11-04Improvedv0.56.0 - 2026-11-03BreakingImprovedFixedv0.55.0 - 2026-10-31BreakingImprovedFixedv0.54.0 - 2026-10-28BreakingImprovedFixedv0.53.0 - 2026-10-20BreakingImprovedFixedv0.52.0 - 2026-10-17BreakingImprovedFixedv0.51.0 - 2026-10-14BreakingImprovedFixedv0.50.1 - 2026-10-13Improvedv0.50.0 - 2026-10-13ImprovedFixedv0.49.0 - 2026-10-12BreakingImprovedFixedv0.48.0 - 2026-10-09BreakingImprovedv0.47.0 - 2026-10-09BreakingImprovedFixedv0.46.0 - 2026-10-07ImprovedFixedv0.45.0 - 2026-10-06BreakingImprovedFixedv0.44.1 - 2026-10-05Fixedv0.44.0 - 2026-10-05BreakingImprovedFixedv0.43.0 - 2026-10-02Improvedv0.42.0 - 2026-10-02ImprovedFixedv0.41.0 - 2026-09-30BreakingImprovedFixedv0.40.0 - 2026-09-26BreakingImprovedFixedv0.39.0 - 2026-09-23ImprovedFixedv0.38.0 - 2026-09-21ImprovedFixedv0.37.0 - 2026-09-20BreakingImprovedFixedv0.36.0 - 2026-09-17BreakingImprovedFixedv0.35.0 - 2026-09-16BreakingImprovedFixedv0.34.0 - 2026-09-13ImprovedFixedv0.33.1 - 2026-09-10ImprovedFixedv0.33.0 - 2026-09-08BreakingImprovedv0.32.1 - 2026-09-06Fixedv0.32.0 - 2026-09-05BreakingImprovedFixedv0.31.0 - 2026-09-03ImprovedFixedv0.30.0 - 2026-08-30ImprovedFixedv0.29.0 - 2026-08-29BreakingImprovedFixedv0.28.3 - 2026-08-27Fixedv0.28.2 - 2026-08-27ImprovedFixedv0.28.1 - 2026-08-26Fixedv0.28.0 - 2026-08-25Improvedv0.27.0 - 2026-08-23ImprovedFixedv0.26.0 - 2026-08-20BreakingImprovedv0.25.0 - 2026-08-18BreakingImprovedFixedv0.24.0 - 2026-08-08BreakingImprovedFixedv0.23.0 - 2026-07-27BreakingImprovedFixedv0.22.0 - 2026-07-24AddedImprovedFixesv0.21.1 - 2026-07-21ImprovedFixesv0.21.0 - 2026-07-20Addedv0.20.8 - 2026-07-19Addedv0.20.7 - 2026-07-18AddedFixedv0.20.6 - 2026-07-18Fixedv0.20.5 - 2026-07-18ImprovedFixedv0.20.4 - 2026-07-17Improvedv0.20.3 - 2026-07-16AddedImprovedv0.20.2 - 2026-07-14Fixedv0.20.xBreakingAddedFixedv0.19.xAddedImprovedFixedv0.18.xAddedImprovedFixedv0.17.xAddedImprovedFixedv0.16.xAddedImprovedFixedv0.15.xImprovedFixedv0.14.xImprovedFixedv0.13.xAddedImprovedv0.12.xImprovedFixedv0.11.xBreakingAddedImprovedFixedv0.10.xAddedImproved