@defold-typescript/types 0.51.0 → 0.52.0

package/generated/versions/defold-1.13.2/sys.d.ts

@@ -73,7 +73,7 @@ declare global {
       /**
        * Loaded payload for a successful request.
        */
-      buffer?: Opaque<"buffer">;
+      buffer?: Opaque<"buffer"> & { length: LuaLengthMethod<number> };
     }
     /**
      * URL opening attributes
@@ -317,7 +317,40 @@ declare global {
      * }
      * ```
      */
-    function get_config_int(key: string, default_value?: number): number;
+    function get_config_int(key: string): number;
+    /**
+     * Get integer config value from the game.project configuration file with optional default value
+     *
+     * @param key - key to get value for. The syntax is SECTION.KEY
+     * @param default_value - (optional) default value to return if the value does not exist
+     * @returns config value as an integer. default_value if the config key does not exist. 0 if no default value was supplied.
+     * @example
+     * Get user config value
+     * ```ts
+     * const speed = sys.get_config_int("my_game.speed", 20); // with default value
+     * ```
+     * @example
+     * ```ts
+     * const testmode = sys.get_config_int("my_game.testmode"); // without default value
+     * if (testmode !== undefined) {
+     *   // do stuff
+     * }
+     * ```
+     */
+    function get_config_int(key: string, default_value: number): number;
+    /**
+     * Get number config value from the game.project configuration file with optional default value
+     *
+     * @param key - key to get value for. The syntax is SECTION.KEY
+     * @param default_value - (optional) default value to return if the value does not exist
+     * @returns config value as an number. default_value if the config key does not exist. 0 if no default value was supplied.
+     * @example
+     * ```ts
+     * // Get user config value
+     * const speed = sys.get_config_number("my_game.speed", 20.0);
+     * ```
+     */
+    function get_config_number(key: string): number;
     /**
      * Get number config value from the game.project configuration file with optional default value
      *
@@ -330,7 +363,7 @@ declare global {
      * const speed = sys.get_config_number("my_game.speed", 20.0);
      * ```
      */
-    function get_config_number(key: string, default_value?: number): number;
+    function get_config_number(key: string, default_value: number): number;
     /**
      * Returns the current network connectivity status
      * on mobile platforms.
@@ -443,7 +476,22 @@ declare global {
      * }
      * ```
      */
-    function get_sys_info(options?: sys.sys_info_options): sys.sys_info;
+    function get_sys_info(): sys.sys_info;
+    /**
+     * Returns a table with system information.
+     *
+     * @param options - optional system-information options
+     * @returns system information
+     * @example
+     * ```ts
+     * // How to get system information:
+     * const info = sys.get_sys_info();
+     * if (info.system_name === "HTML5") {
+     *   // We are running in a browser.
+     * }
+     * ```
+     */
+    function get_sys_info(options: sys.sys_info_options): sys.sys_info;
     /**
      * If the file exists, it must have been created by `sys.save` to be loaded.
      * This function will raise a Lua error if an error occurs while loading the file.
@@ -489,7 +537,7 @@ declare global {
      * const asset_2 = sys.load_buffer("/my/absolute/path");
      * ```
      */
-    function load_buffer(path: string): Opaque<"buffer">;
+    function load_buffer(path: string): Opaque<"buffer"> & { length: LuaLengthMethod<number> };
     /**
      * The sys.load_buffer function will first try to load the resource
      * from any of the mounted resource locations and return the data if
@@ -588,7 +636,23 @@ declare global {
      * }
      * ```
      */
-    function open_url(url: string, attributes?: sys.open_url_attributes): boolean;
+    function open_url(url: string): boolean;
+    /**
+     * Open URL in default application, typically a browser
+     *
+     * @param url - url to open
+     * @param attributes - optional URL opening attributes
+     * @returns a boolean indicating if the url could be opened or not
+     * @example
+     * ```ts
+     * // Open an URL:
+     * const success = sys.open_url("http://www.defold.com", { target: "_blank" });
+     * if (!success) {
+     *   // could not open the url...
+     * }
+     * ```
+     */
+    function open_url(url: string, attributes: sys.open_url_attributes): boolean;
     /**
      * Reboots the game engine with a specified set of arguments.
      * Arguments will be translated into command line arguments. Calling reboot

package/generated/versions/defold-1.13.2/vmath.d.ts

@@ -69,30 +69,6 @@ declare global {
      * ```
      */
     function cross(v1: Vector3, v2: Vector3): Vector3;
-    /**
-     * The returned value is a scalar defined as:
-     * `P ⋅ Q = |P| |Q| cos θ`
-     * where θ is the angle between the vectors P and Q.
-     *
-     * - If the dot product is positive then the angle between the vectors is below 90 degrees.
-     * - If the dot product is zero the vectors are perpendicular (at right-angles to each other).
-     * - If the dot product is negative then the angle between the vectors is more than 90 degrees.
-     *
-     * @param v1 - first vector
-     * @param v2 - second vector
-     * @returns dot product
-     * @example
-     * ```ts
-     * const vector1 = vmath.vector3(1, 0, 0);
-     * const vector2 = vmath.vector3(0, 1, 0);
-     *
-     * if (vmath.dot(vector1, vector2) === 0) {
-     *   // The two vectors are perpendicular (at right-angles to each other)
-     *   // ...
-     * }
-     * ```
-     */
-    function dot(v1: Vector3 | Vector4, v2: Vector3 | Vector4): number;
     /**
      * The resulting matrix is the inverse of the supplied matrix.
      * For ortho-normal matrices, e.g. regular object transformation,

package/generated/vmath.d.ts

@@ -69,30 +69,6 @@ declare global {
      * ```
      */
     function cross(v1: Vector3, v2: Vector3): Vector3;
-    /**
-     * The returned value is a scalar defined as:
-     * `P ⋅ Q = |P| |Q| cos θ`
-     * where θ is the angle between the vectors P and Q.
-     *
-     * - If the dot product is positive then the angle between the vectors is below 90 degrees.
-     * - If the dot product is zero the vectors are perpendicular (at right-angles to each other).
-     * - If the dot product is negative then the angle between the vectors is more than 90 degrees.
-     *
-     * @param v1 - first vector
-     * @param v2 - second vector
-     * @returns dot product
-     * @example
-     * ```ts
-     * const vector1 = vmath.vector3(1, 0, 0);
-     * const vector2 = vmath.vector3(0, 1, 0);
-     *
-     * if (vmath.dot(vector1, vector2) === 0) {
-     *   // The two vectors are perpendicular (at right-angles to each other)
-     *   // ...
-     * }
-     * ```
-     */
-    function dot(v1: Vector3 | Vector4, v2: Vector3 | Vector4): number;
     /**
      * The resulting matrix is the inverse of the supplied matrix.
      * For ortho-normal matrices, e.g. regular object transformation,

package/identity-vocabulary.json

@@ -152,6 +152,7 @@
     "go.PLAYBACK": "number",
     "graphics.BLEND_EQUATION": "number",
     "graphics.BLEND_FACTOR": "number",
+    "graphics.BlendFactor": "number",
     "graphics.BUFFER_TYPE": "number",
     "graphics.BufferType": "number",
     "graphics.COMPARE_FUNC": "number",
@@ -212,6 +213,7 @@
     "render.CONTEXT_EVENT": "number",
     "render.FRUSTUM_PLANES": "number",
     "render.RENDER_TARGET_FLAG": "number",
+    "render.RenderTargetTextureType": "number",
     "render.SORT": "number",
     "sys.NETWORK": "number",
     "sys.NetworkConnectivity": "number",
@@ -297,6 +299,7 @@
     "b2d.joint.create_wheel:param:definition",
     "b2d.shape.ray_cast:param:max_fraction",
     "b2d.shape.set_shape:param:update_mass",
+    "buffer.get_bytes:param:stream_name",
     "go.cancel_animations:param:url",
     "go.world_to_local_position:param:url",
     "go.world_to_local_transform:param:url",
@@ -327,7 +330,6 @@
     "factory.unload:param:url",
     "gui.move_above:param:reference",
     "gui.move_below:param:reference",
-    "gui.set:param:value",
     "gui.set_parent:param:parent",
     "html5.set_interaction_listener:param:callback",
     "resource.create_buffer:param:table",
@@ -339,6 +341,16 @@
   ],
   "parameterCorrections": {
     "buffer.get_bytes:param:stream_name": { "pins": [["hash"]], "adds": ["string"] },
+    "bullet3d.constraint.get_slider_motor:param:motor": {
+      "pins": [["string"]],
+      "adds": ["\"linear\"", "\"angular\""],
+      "removes": ["string"]
+    },
+    "bullet3d.constraint.set_slider_motor:param:motor": {
+      "pins": [["string"]],
+      "adds": ["\"linear\"", "\"angular\""],
+      "removes": ["string"]
+    },
     "camera.get_aspect_ratio:param:camera": {
       "pins": [["url", "number", "nil"]],
       "adds": ["string", "Hash"]
@@ -439,13 +451,11 @@
       "pins": [["nil", "string", "constant"]],
       "adds": ["Hash"]
     },
+    "gui.clone_tree:param:node": { "pins": [["node"]], "adds": ["undefined"] },
+    "gui.get_tree:param:node": { "pins": [["node"]], "adds": ["undefined"] },
     "gui.screen_to_local:param:screen_position": { "pins": [["vector3"]], "adds": ["Vector4"] },
     "gui.set_rotation:param:rotation": { "pins": [["quaternion", "vector4"]], "adds": ["Vector3"] },
     "gui.set_screen_position:param:screen_position": { "pins": [["vector3"]], "adds": ["Vector4"] },
-    "gui.set:param:value": {
-      "pins": [["number", "vector4", "vector3", "quaternion"]],
-      "adds": ["Matrix4", "Hash"]
-    },
     "model.get_mesh_enabled:param:mesh_id": {
       "pins": [["string", "hash", "url"]],
       "removes": ["Url"]
@@ -458,15 +468,26 @@
     "physics.get_maskbit:param:group": { "pins": [["string"]], "adds": ["Hash"] },
     "physics.set_group:param:group": { "pins": [["string"]], "adds": ["Hash"] },
     "physics.set_maskbit:param:group": { "pins": [["string"]], "adds": ["Hash"] },
+    "render.disable_state:param:state": {
+      "pins": [["graphics.STATE"]],
+      "adds": ["graphics.State"],
+      "removes": ["graphics.STATE"]
+    },
     "render.disable_texture:param:binding": {
       "pins": [["texture", "string", "hash"]],
-      "adds": ["number"]
+      "adds": ["number"],
+      "removes": ["Opaque<\"texture\">"]
     },
     "render.draw:param:predicate": {
-      "pins": [["number"], ["render_predicate"]],
+      "pins": [["number"]],
       "adds": ["Opaque<\"render_predicate\">"],
       "removes": ["number"]
     },
+    "render.enable_state:param:state": {
+      "pins": [["graphics.STATE"]],
+      "adds": ["graphics.State"],
+      "removes": ["graphics.STATE"]
+    },
     "render.enable_texture:param:handle_or_name": {
       "pins": [["texture", "string", "hash"]],
       "adds": ["Opaque<\"render_target\">", "number"]
@@ -479,6 +500,26 @@
       "pins": [["render_target"]],
       "adds": ["string", "Hash"]
     },
+    "render.set_blend_func_separate:param:destination_factor_alpha": {
+      "pins": [["number"]],
+      "adds": ["graphics.BlendFactor"],
+      "removes": ["number"]
+    },
+    "render.set_blend_func_separate:param:destination_factor_color": {
+      "pins": [["number"]],
+      "adds": ["graphics.BlendFactor"],
+      "removes": ["number"]
+    },
+    "render.set_blend_func_separate:param:source_factor_alpha": {
+      "pins": [["number"]],
+      "adds": ["graphics.BlendFactor"],
+      "removes": ["number"]
+    },
+    "render.set_blend_func_separate:param:source_factor_color": {
+      "pins": [["number"]],
+      "adds": ["graphics.BlendFactor"],
+      "removes": ["number"]
+    },
     "render.set_camera:param:camera": {
       "pins": [["url", "number", "nil"]],
       "adds": ["string", "Hash"]
@@ -539,6 +580,10 @@
         "undefined"
       ]
     },
+    "bullet3d.shape.get_shape": {
+      "pins": [["bullet3d.shape.definition"]],
+      "replaces": ["bullet3d.shape.definition", "{ type: typeof bullet3d.shape.SHAPE_TYPE_MESH }"]
+    },
     "collectionfactory.create": {
       "pins": [["table"], ["table<hash, hash>"]],
       "replaces": ["LuaTable<Hash, Hash> & { get: LuaTableGetMethod<string, Hash> }"]

package/index.d.ts

@@ -35,6 +35,8 @@ import "./src/go-overloads";
 import "./src/component-properties";
 import "./generated/graphics";
 import "./generated/gui";
+import "./src/gui-overloads";
+import "./src/gui-texture-removal";
 import "./generated/html5";
 import "./generated/http";
 import "./generated/image";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defold-typescript/types",
-  "version": "0.51.0",
+  "version": "0.52.0",
   "description": "TypeScript types for the Defold engine's Lua APIs.",
   "license": "MIT",
   "repository": {
@@ -93,6 +93,7 @@
     "!scripts/example-typecheck.ts",
     "!scripts/example-variant-drift.ts",
     "!scripts/engine-binding-extract.ts",
+    "!scripts/go-instance-functions.ts",
     "!scripts/binding-pin.ts",
     "!scripts/sync-engine-bindings.ts",
     "!scripts/engine-binding-diff.ts",

package/scripts/generate-api-availability.ts

@@ -28,37 +28,17 @@ import {
 } from "../src/emit-dts";
 import { splitTopLevel } from "../src/luals-type-expr";
 import { type ApiTarget, loadApiTargets, loadTargetModules } from "./regen";
+import { compareVersions, versionOf } from "./target-version";
 
 const PACKAGE_ROOT = resolve(import.meta.dir, "..");
 const MIGRATIONS_PATH = resolve(PACKAGE_ROOT, "api-migrations.json");
 const AVAILABILITY_PATH = resolve(PACKAGE_ROOT, "api-availability.json");
 
-const VERSION_FROM_ID = /^defold-(\d+\.\d+\.\d+)$/;
-
 export interface AvailabilityArtifact {
   readonly versions: readonly string[];
   readonly records: readonly ApiAvailability[];
 }
 
-export function versionOf(target: ApiTarget): string {
-  const match = VERSION_FROM_ID.exec(target.id);
-  if (!match?.[1]) throw new Error(`cannot derive a release version from target id "${target.id}"`);
-  return match[1];
-}
-
-function versionTuple(version: string): number[] {
-  return version.split(".").map((part) => Number.parseInt(part, 10));
-}
-
-function compareVersions(a: string, b: string): number {
-  const [ta, tb] = [versionTuple(a), versionTuple(b)];
-  for (let index = 0; index < Math.max(ta.length, tb.length); index += 1) {
-    const diff = (ta[index] ?? 0) - (tb[index] ?? 0);
-    if (diff !== 0) return diff;
-  }
-  return 0;
-}
-
 // Every complete committed surface, newest first. The committed targets are the
 // `source == null` entries of `api-targets.json` (ref-doc-sourced historical
 // targets are resolved on demand and never a committed-derivation input). This

package/scripts/generate-api-signatures.ts

@@ -1,16 +1,18 @@
 import { resolve } from "node:path";
 import { symbolIdentityKey } from "../src/api-availability";
-import type { SlotTypes } from "../src/emit-dts";
-import { selectCompleteVersionSurfaces, versionOf } from "./generate-api-availability";
+import type { SlotType, SlotTypes } from "../src/emit-dts";
+import { signatureArmsFor } from "../src/signature-store";
+import { selectCompleteVersionSurfaces } from "./generate-api-availability";
 import {
   type ApiTarget,
-  type GenerateOptions,
   generateModuleSignatures,
   loadApiTargets,
   loadTargetModules,
   type ModuleManifestEntry,
+  type TargetBindingOptions,
 } from "./regen";
 import { loadSignatureFile } from "./signature-store-fs";
+import { versionOf } from "./target-version";
 
 const PACKAGE_ROOT = resolve(import.meta.dir, "..");
 const SIGNATURES_PATH = resolve(PACKAGE_ROOT, "api-signatures.json");
@@ -35,9 +37,7 @@ export interface BuildSignaturesOptions {
   // every target is emitted ungated and with no binding-pinned correction.
   // Supplied by the in-repo callers only: the vendored bindings it reads are not
   // published.
-  readonly emitOptionsOf?: (
-    target: ApiTarget,
-  ) => Pick<GenerateOptions, "registeredConstants" | "bindingEvidence">;
+  readonly emitOptionsOf?: (target: ApiTarget) => TargetBindingOptions;
 }
 
 // The authored replacement for a symbol the skip filter withheld, read from the
@@ -45,22 +45,59 @@ export interface BuildSignaturesOptions {
 // One seam keeps all three artifacts consistent: `overloads-signature-parity`
 // pins the store to the `src/*-overloads.d.ts` declarations, so folding the
 // store in cannot drift from the surface a consumer actually compiles against.
-function authoredSignature(packageRoot: string, namespace: string, fqn: string): string | null {
+// Only the arms the target's version declares are folded.
+function authoredSignature(
+  packageRoot: string,
+  namespace: string,
+  fqn: string,
+  version: string,
+): string | null {
   const store = loadSignatureFile(resolve(packageRoot, "signatures", `${namespace}.json`));
-  const forms = store[fqn]?.signatures ?? [];
+  const override = store[fqn];
+  const forms = override ? signatureArmsFor(override, version).signatures : [];
   return forms.length > 0 ? forms.join("\n") : null;
 }
 
+interface UnfilteredSurface {
+  readonly entries: readonly ModuleManifestEntry[];
+  readonly of: ReadonlyMap<ModuleManifestEntry, ModuleManifestEntry>;
+}
+
+const unfilteredSurfaces = new WeakMap<readonly ModuleManifestEntry[], UnfilteredSurface>();
+
+// The surface with every member's `skipFunctions` cleared, built once per
+// surface: dropping functions moves no type declaration, so it routes exactly
+// as the filtered one does.
+function unfilteredSurfaceOf(surface: readonly ModuleManifestEntry[]): UnfilteredSurface {
+  let unfiltered = unfilteredSurfaces.get(surface);
+  if (unfiltered === undefined) {
+    const of = new Map(surface.map((member) => [member, { ...member, skipFunctions: [] }]));
+    unfiltered = { entries: [...of.values()], of };
+    unfilteredSurfaces.set(surface, unfiltered);
+  }
+  return unfiltered;
+}
+
 // The symbols `skipFunctions` removed from this module, as the difference
 // between the unfiltered and filtered signature emits. Derived rather than
 // re-matched so the withholding rules stay owned by `prepareGeneratedModule`.
-export function withheldSymbols(entry: ModuleManifestEntry): { key: string; fqn: string }[] {
+// Both emits route in `surface`, the modules the entry is emitted beside, so a
+// slot naming a sibling's type resolves in the unfiltered emit too.
+export function withheldSymbols(
+  entry: ModuleManifestEntry,
+  surface: readonly ModuleManifestEntry[],
+): { key: string; fqn: string }[] {
   if ((entry.skipFunctions ?? []).length === 0) return [];
   const kept = new Set(
-    generateModuleSignatures(entry).map(({ identity }) => symbolIdentityKey(identity)),
+    generateModuleSignatures(entry, { surface }).map(({ identity }) => symbolIdentityKey(identity)),
   );
+  const unfiltered = unfilteredSurfaceOf(surface);
+  const self = unfiltered.of.get(entry);
+  if (self === undefined) {
+    throw new Error(`module "${entry.namespace}" is not a member of the surface it is emitted in`);
+  }
   const withheld: { key: string; fqn: string }[] = [];
-  for (const { identity } of generateModuleSignatures({ ...entry, skipFunctions: [] })) {
+  for (const { identity } of generateModuleSignatures(self, { surface: unfiltered.entries })) {
     const key = symbolIdentityKey(identity);
     if (kept.has(key)) continue;
     const fqn = key.split("\0")[2] as string;
@@ -69,6 +106,18 @@ export function withheldSymbols(entry: ModuleManifestEntry): { key: string; fqn:
   return withheld;
 }
 
+// The slots two arms record identically. One ledger cannot describe arms whose
+// types differ at a slot, so that slot is dropped and its row falls back to the
+// ref-doc token.
+function commonSlots(a: SlotTypes, b: SlotTypes): SlotTypes {
+  const common: Record<string, SlotType> = {};
+  for (const [slot, record] of Object.entries(a)) {
+    const other = b[slot];
+    if (other?.type === record.type && other.optional === record.optional) common[slot] = record;
+  }
+  return common;
+}
+
 function sortObjectKeys<T>(record: Record<string, T>): Record<string, T> {
   const sorted: Record<string, T> = {};
   for (const key of Object.keys(record).sort()) sorted[key] = record[key] as T;
@@ -86,9 +135,21 @@ export function buildSignaturesArtifact(options: BuildSignaturesOptions = {}): S
     const perSymbol: Record<string, string> = {};
     const perSymbolSlots: Record<string, SlotTypes> = {};
     const emitOptions = options.emitOptionsOf?.(target);
-    for (const entry of loadTargetModules(target, packageRoot)) {
+    const surface = loadTargetModules(target, packageRoot);
+    for (const entry of surface) {
       for (const signature of generateModuleSignatures(entry, emitOptions)) {
         const key = symbolIdentityKey(signature.identity);
+        // Two ref-doc elements can normalize to one identity (the Box2D backend
+        // forms of a `b2d.world` query), so each keeps its arms in fixture order
+        // and the key keeps only the slots every arm shares.
+        const earlier = perSymbol[key];
+        if (earlier !== undefined) {
+          perSymbol[key] = `${earlier}\n${signature.tsSignature}`;
+          const common = commonSlots(perSymbolSlots[key] ?? {}, signature.slotTypes);
+          if (Object.keys(common).length > 0) perSymbolSlots[key] = common;
+          else delete perSymbolSlots[key];
+          continue;
+        }
         perSymbol[key] = signature.tsSignature;
         if (Object.keys(signature.slotTypes).length > 0) {
           perSymbolSlots[key] = sortObjectKeys({ ...signature.slotTypes });
@@ -96,8 +157,8 @@ export function buildSignaturesArtifact(options: BuildSignaturesOptions = {}): S
       }
       // An authored fold replaces the declaration text wholesale, so whatever
       // slots the generated emit had recorded no longer describe it.
-      for (const { key, fqn } of withheldSymbols(entry)) {
-        const authored = authoredSignature(packageRoot, entry.namespace, fqn);
+      for (const { key, fqn } of withheldSymbols(entry, surface)) {
+        const authored = authoredSignature(packageRoot, entry.namespace, fqn, version);
         if (authored !== null) {
           perSymbol[key] = authored;
           delete perSymbolSlots[key];

package/scripts/materialize-version.ts

@@ -2,19 +2,23 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import {
   type ApiTarget,
-  type GenerateOptions,
+  GO_INSTANCE_SRC_AUGMENTATIONS,
   generateBuiltinMessagesDeclaration,
   generateModuleDeclaration,
   generateVersionIndex,
+  goInstanceFreeSurface,
+  goInstanceWalls,
   KIND_MODULE_MANIFEST,
   type KindManifestEntry,
   kindStdlibReferences,
+  loadGoInstanceFunctions,
   loadSrcAugmentations,
   loadTargetEditorModules,
   MESSAGES_MANIFEST,
   type ModuleManifestEntry,
   type ResolveTargetOptions,
   resolveTargetModules,
+  type TargetBindingOptions,
 } from "./regen";
 
 export {
@@ -41,6 +45,11 @@ export interface RenderMaterializedKindIndexOptions {
   // the universal set outright — an editor kind is disjoint from the runtime
   // surface, not a narrowing of it.
   readonly editorModules?: readonly string[];
+  // The universal modules the surface also carries as copies without the
+  // functions that need a game object, set when the target records which those
+  // are. A kind with no game object imports the copies instead and drops the
+  // augmentations marked as needing one; every other kind ignores it.
+  readonly goInstanceFreeModules?: readonly string[];
 }
 
 // The installed subpath a materialized kind re-exports its factory from: the
@@ -57,11 +66,21 @@ function installedFactoryModule(entry: KindManifestEntry): string {
 export function renderMaterializedKindIndex(opts: RenderMaterializedKindIndexOptions): string {
   const entry = KIND_MODULE_MANIFEST.find((e) => e.kind === opts.kind);
   if (!entry) throw new Error(`unknown script kind: ${opts.kind}`);
+  const freeDir = entry.goInstanceFreeDir;
+  const copied =
+    freeDir === undefined || opts.goInstanceFreeModules === undefined
+      ? null
+      : new Set(opts.goInstanceFreeModules);
+  const universal = opts.universalModules.filter(
+    (mod) => copied === null || !GO_INSTANCE_SRC_AUGMENTATIONS.includes(mod),
+  );
   const modules =
     entry.only === undefined
-      ? [...new Set(["engine-globals", ...opts.universalModules])].sort()
+      ? [...new Set(["engine-globals", ...universal])].sort()
       : [...(opts.editorModules ?? [])];
-  const lines = modules.map((mod) => `import "../${mod}";`);
+  const lines = modules.map((mod) =>
+    copied?.has(mod) ? `import "../${freeDir}/${mod}";` : `import "../${mod}";`,
+  );
   if (entry.only === undefined && opts.restrictedModule) {
     lines.push(`import "../${opts.restrictedModule}";`);
   }
@@ -89,14 +108,15 @@ export interface BuildVersionedSurfaceOptions {
   // script kind without the generator knowing what a script kind is.
   readonly excludeModules?: readonly string[];
   // The hand-authored `src/*` augmentations to carry beside the modules.
-  // Defaults to reading them from the types package on disk; a caller with no
-  // filesystem (a Worker) supplies the bytes and gets an identical file map.
+  // Defaults to reading the target's set (`srcAugmentationModulesFor`) from the
+  // types package on disk; a caller with no filesystem (a Worker) supplies the
+  // same bytes and gets an identical file map.
   readonly augmentations?: readonly VersionedSurfaceFile[];
   // What the target's own engine source decides for its emit
   // (`targetBindingOptions`). Only an in-repo caller rebuilding a vendored
   // target's committed surface passes it; a published install vendors no engine
   // source, and the ref-doc targets it materializes have none to read.
-  readonly emitOptions?: Pick<GenerateOptions, "registeredConstants" | "bindingEvidence">;
+  readonly emitOptions?: TargetBindingOptions;
 }
 
 export interface MaterializeVersionedSurfaceOptions extends BuildVersionedSurfaceOptions {
@@ -142,7 +162,7 @@ export async function buildVersionedSurfaceFiles(
   ).filter((entry) => kept(entry.outFile));
 
   const augmentations = (
-    opts.augmentations ?? loadSrcAugmentations(opts.resolveOpts?.packageRoot ?? undefined)
+    opts.augmentations ?? loadSrcAugmentations(opts.resolveOpts?.packageRoot ?? undefined, target)
   ).filter((file) => kept(file.path));
 
   // Re-rooting an entry makes it a new object no committed manifest holds, so
@@ -158,6 +178,27 @@ export async function buildVersionedSurfaceFiles(
       })),
   );
 
+  // A target whose engine source records the functions that need a game object
+  // carries, for each kind without one, copies of the modules declaring them
+  // with those functions withheld. Nothing else differs, so a target with no
+  // record writes no copy.
+  const walls = goInstanceWalls(
+    modules,
+    loadGoInstanceFunctions(target, opts.resolveOpts?.packageRoot ?? undefined),
+  );
+  for (const kind of KIND_MODULE_MANIFEST) {
+    const dir = kind.goInstanceFreeDir;
+    if (dir === undefined || walls.size === 0) continue;
+    const surface = rerooted(goInstanceFreeSurface(modules, walls, dir).surface);
+    for (const entry of surface) {
+      if (!entry.outFile.startsWith(`${dir}/`)) continue;
+      files.push({
+        path: entry.outFile,
+        contents: generateModuleDeclaration(entry, { ...opts.emitOptions, surface }).contents,
+      });
+    }
+  }
+
   files.push(...augmentations);
   files.push({ path: "core-types.d.ts", contents: CORE_TYPES_REEXPORT });