@defold-typescript/types 0.34.0 → 0.36.0

package/generated/versions/defold-1.13.0/render.d.ts

@@ -38,13 +38,13 @@ declare global {
      * @example
      * ```ts
      * // Clear the color buffer and the depth buffer.
-     * render.clear({
-     *   [graphics.BUFFER_TYPE_COLOR0_BIT]: vmath.vector4(0, 0, 0, 0),
-     *   [graphics.BUFFER_TYPE_DEPTH_BIT]: 1,
-     * });
+     * const buffers = new LuaMap<render.ClearBufferKey, number | Vector4>();
+     * buffers.set(graphics.BUFFER_TYPE_COLOR0_BIT, vmath.vector4(0, 0, 0, 0));
+     * buffers.set(graphics.BUFFER_TYPE_DEPTH_BIT, 1);
+     * render.clear(buffers);
      * ```
      */
-    function clear(buffers: LuaMap<number, number | Vector4>): void;
+    function clear(buffers: LuaMap<number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR0_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_DEPTH_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_STENCIL_BIT" }, number | Vector4>): void;
     /**
      * Constant buffers are used to set shader program variables and are optionally passed to the `render.draw()` function.
      * The buffer's constant elements can be indexed like an ordinary Lua table, but you can't iterate over them with pairs() or ipairs().
@@ -128,7 +128,7 @@ declare global {
      * render.draw(self.tile_pred);
      * ```
      */
-    function disable_state(state: Opaque<"constant">): void;
+    function disable_state(state: number & { readonly __brand: "graphics.STATE_DEPTH_TEST" } | number & { readonly __brand: "graphics.STATE_STENCIL_TEST" } | number & { readonly __brand: "graphics.STATE_BLEND" } | number & { readonly __brand: "graphics.STATE_ALPHA_TEST" } | number & { readonly __brand: "graphics.STATE_CULL_FACE" } | number & { readonly __brand: "graphics.STATE_POLYGON_OFFSET_FILL" }): void;
     /**
      * Disables a texture that has previourly been enabled.
      *
@@ -307,7 +307,7 @@ declare global {
      * render.disable_state(graphics.STATE_STENCIL_TEST);
      * ```
      */
-    function enable_state(state: Opaque<"constant">): void;
+    function enable_state(state: number & { readonly __brand: "graphics.STATE_DEPTH_TEST" } | number & { readonly __brand: "graphics.STATE_STENCIL_TEST" } | number & { readonly __brand: "graphics.STATE_BLEND" } | number & { readonly __brand: "graphics.STATE_ALPHA_TEST" } | number & { readonly __brand: "graphics.STATE_CULL_FACE" } | number & { readonly __brand: "graphics.STATE_POLYGON_OFFSET_FILL" }): void;
     /**
      * Sets the specified texture handle for a render target attachment or a regular texture
      * that should be used for rendering. The texture can be bound to either a texture unit
@@ -502,154 +502,6 @@ declare global {
      * ```
      */
     function predicate(tags: (string | Hash)[]): number;
-    /**
-     * Creates a new render target according to the supplied
-     * specification table.
-     * The table should contain keys specifying which buffers should be created
-     * with what parameters. Each buffer key should have a table value consisting
-     * of parameters. The following parameter keys are available:
-     *
-     * Key
-     * Values
-     *
-     * `format`
-     * `graphics.TEXTURE_FORMAT_LUMINANCE`
-     * `graphics.TEXTURE_FORMAT_RGB`
-     * `graphics.TEXTURE_FORMAT_RGBA`
-     * `graphics.TEXTURE_FORMAT_DEPTH`
-     * `graphics.TEXTURE_FORMAT_STENCIL`
-     * `graphics.TEXTURE_FORMAT_RGBA32F`
-     * `graphics.TEXTURE_FORMAT_RGBA16F`
-     *
-     * `width`
-     * number
-     *
-     * `height`
-     * number
-     *
-     * `min_filter` (optional)
-     * `graphics.TEXTURE_FILTER_LINEAR`
-     * `graphics.TEXTURE_FILTER_NEAREST`
-     *
-     * `mag_filter` (optional)
-     * `graphics.TEXTURE_FILTER_LINEAR`
-     * `graphics.TEXTURE_FILTER_NEAREST`
-     *
-     * `u_wrap` (optional)
-     * `graphics.TEXTURE_WRAP_CLAMP_TO_BORDER`
-     * `graphics.TEXTURE_WRAP_CLAMP_TO_EDGE`
-     * `graphics.TEXTURE_WRAP_MIRRORED_REPEAT`
-     * `graphics.TEXTURE_WRAP_REPEAT`
-     *
-     * `v_wrap` (optional)
-     * `graphics.TEXTURE_WRAP_CLAMP_TO_BORDER`
-     * `graphics.TEXTURE_WRAP_CLAMP_TO_EDGE`
-     * `graphics.TEXTURE_WRAP_MIRRORED_REPEAT`
-     * `graphics.TEXTURE_WRAP_REPEAT`
-     *
-     * `flags` (optional)
-     * `render.TEXTURE_BIT` (only applicable to depth and stencil buffers)
-     *
-     * The render target can be created to support multiple color attachments. Each attachment can have different format settings and texture filters,
-     * but attachments must be added in sequence, meaning you cannot create a render target at slot 0 and 3.
-     * Instead it has to be created with all four buffer types ranging from [0..3] (as denoted by graphics.BUFFER_TYPE_COLORX_BIT where 'X' is the attachment you want to create).
-     * It is not guaranteed that the device running the script can support creating render targets with multiple color attachments. To check if the device can support multiple attachments,
-     * you can check if the `render` table contains any of the `BUFFER_TYPE_COLOR1_BIT`, `BUFFER_TYPE_COLOR2_BIT` or `BUFFER_TYPE_COLOR3_BIT` constants:
-     *
-     * `function init(self)
-     * if graphics.BUFFER_TYPE_COLOR1_BIT == nil then
-     * -- this devices does not support multiple color attachments
-     * end
-     * end
-     * `
-     *
-     * @param name - render target name
-     * @param parameters - table of buffer parameters, see the description for available keys and values
-     * @returns new render target
-     * @example
-     * ```ts
-     * // How to create a new render target and draw to it:
-     * export default defineScript({
-     *   init() {
-     *     // render target buffer parameters
-     *     const color_params = {
-     *       format: graphics.TEXTURE_FORMAT_RGBA,
-     *       width: render.get_window_width(),
-     *       height: render.get_window_height(),
-     *       min_filter: graphics.TEXTURE_FILTER_LINEAR,
-     *       mag_filter: graphics.TEXTURE_FILTER_LINEAR,
-     *       u_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
-     *       v_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
-     *     };
-     *     const depth_params = {
-     *       format: graphics.TEXTURE_FORMAT_DEPTH,
-     *       width: render.get_window_width(),
-     *       height: render.get_window_height(),
-     *       u_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
-     *       v_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
-     *     };
-     *     return {
-     *       my_render_target: render.render_target({
-     *         [graphics.BUFFER_TYPE_COLOR0_BIT]: color_params,
-     *         [graphics.BUFFER_TYPE_DEPTH_BIT]: depth_params,
-     *       }),
-     *     };
-     *   },
-     *
-     *   update(self, dt) {
-     *     // enable target so all drawing is done to it
-     *     render.set_render_target(self.my_render_target);
-     *
-     *     // draw a predicate to the render target
-     *     render.draw(self.my_pred);
-     *   },
-     * });
-     *
-     * // How to create a render target with multiple outputs:
-     * export default defineScript({
-     *   init() {
-     *     // render target buffer parameters
-     *     const color_params_rgba = {
-     *       format: graphics.TEXTURE_FORMAT_RGBA,
-     *       width: render.get_window_width(),
-     *       height: render.get_window_height(),
-     *       min_filter: graphics.TEXTURE_FILTER_LINEAR,
-     *       mag_filter: graphics.TEXTURE_FILTER_LINEAR,
-     *       u_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
-     *       v_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
-     *     };
-     *     const color_params_float = {
-     *       format: graphics.TEXTURE_FORMAT_RG32F,
-     *       width: render.get_window_width(),
-     *       height: render.get_window_height(),
-     *       min_filter: graphics.TEXTURE_FILTER_LINEAR,
-     *       mag_filter: graphics.TEXTURE_FILTER_LINEAR,
-     *       u_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
-     *       v_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
-     *     };
-     *
-     *     // Create a render target with three color attachments
-     *     // Note: No depth buffer is attached here
-     *     return {
-     *       my_render_target: render.render_target({
-     *         [graphics.BUFFER_TYPE_COLOR0_BIT]: color_params_rgba,
-     *         [graphics.BUFFER_TYPE_COLOR1_BIT]: color_params_rgba,
-     *         [graphics.BUFFER_TYPE_COLOR2_BIT]: color_params_float,
-     *       }),
-     *     };
-     *   },
-     *
-     *   update(self, dt) {
-     *     // enable target so all drawing is done to it
-     *     render.enable_render_target(self.my_render_target);
-     *
-     *     // draw a predicate to the render target
-     *     render.draw(self.my_pred);
-     *   },
-     * });
-     * ```
-     */
-    function render_target(name: string, parameters: Record<string | number, unknown>): Opaque<"render_target">;
     /**
      * Sets the blend equation with separate equations for the color and alpha channels.
      *

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

@@ -228,7 +228,7 @@ declare global {
      * }
      * ```
      */
-    function get_connectivity(): Opaque<"constant">;
+    function get_connectivity(): number & { readonly __brand: "sys.NETWORK_DISCONNECTED" } | number & { readonly __brand: "sys.NETWORK_CONNECTED_CELLULAR" } | number & { readonly __brand: "sys.NETWORK_CONNECTED" };
     /**
      * Returns a table with engine information.
      *

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

@@ -91,25 +91,6 @@ declare global {
      * ```
      */
     function dot(v1: Vector3 | Vector4, v2: Vector3 | Vector4): number;
-    /**
-     * Converts euler angles (x, y, z) in degrees into a quaternion
-     * The error is guaranteed to be less than 0.001.
-     * If the first argument is vector3, its values are used as x, y, z angles.
-     *
-     * @param x - rotation around x-axis in degrees or vector3 with euler angles in degrees
-     * @param y - rotation around y-axis in degrees
-     * @param z - rotation around z-axis in degrees
-     * @returns quaternion describing an equivalent rotation (231 (YZX) rotation sequence)
-     * @example
-     * ```ts
-     * const q = vmath.euler_to_quat(0, 45, 90);
-     * print(q); // => vmath.quat(0.27059805393219, 0.27059805393219, 0.65328145027161, 0.65328145027161)
-     *
-     * const v = vmath.vector3(0, 0, 90);
-     * print(vmath.euler_to_quat(v)); // => vmath.quat(0, 0, 0.70710676908493, 0.70710676908493)
-     * ```
-     */
-    function euler_to_quat(x: number | Vector3, y: number, z: number): Quaternion;
     /**
      * The resulting matrix is the inverse of the supplied matrix.
      * For ortho-normal matrices, e.g. regular object transformation,

package/generated/versions/defold-1.13.0/window.d.ts

@@ -1,6 +1,4 @@
 /** @noSelfInFile */
-import type { Opaque } from "../../../src/core-types";
-
 declare global {
   /**
    * Functions and constants to access the window, window event listeners
@@ -58,7 +56,7 @@ declare global {
      *
      * - `window.DIMMING_OFF`
      */
-    function get_dim_mode(): Opaque<"constant">;
+    function get_dim_mode(): number & { readonly __brand: "window.DIMMING_UNKNOWN" } | number & { readonly __brand: "window.DIMMING_ON" } | number & { readonly __brand: "window.DIMMING_OFF" };
     /**
      * This returns the content scale of the current display.
      *
@@ -113,7 +111,7 @@ declare global {
      *
      * - `window.DIMMING_OFF`
      */
-    function set_dim_mode(mode: Opaque<"constant">): void;
+    function set_dim_mode(mode: number & { readonly __brand: "window.DIMMING_ON" } | number & { readonly __brand: "window.DIMMING_OFF" }): void;
     /**
      * Sets a window event listener. Only one window event listener can be set at a time.
      *

package/generated/versions/defold-1.13.0/zlib.d.ts

@@ -28,7 +28,8 @@ declare global {
      * @returns inflated buffer
      * @example
      * ```ts
-     * const data = "\120\94\11\201\200\44\86\0\162\68\133\226\146\162\204\188\116\133\242\204\146\12\133\210\188\228\252\220\130\162\212\226\226\212\20\133\148\196\146\68\61\0\44\67\14\201";
+     * const data =
+     *   "\x78\x5e\x0b\xc9\xc8\x2c\x56\x00\xa2\x44\x85\xe2\x92\xa2\xcc\xbc\x74\x85\xf2\xcc\x92\x0c\x85\xd2\xbc\xe4\xfc\xdc\x82\xa2\xd4\xe2\xe2\xd4\x14\x85\x94\xc4\x92\x44\x3d\x00\x2c\x43\x0e\xc9";
      * const uncompressed_data = zlib.inflate(data);
      * print(uncompressed_data); //> This is a string with uncompressed data.
      * ```

package/generated/vmath.d.ts

@@ -91,25 +91,6 @@ declare global {
      * ```
      */
     function dot(v1: Vector3 | Vector4, v2: Vector3 | Vector4): number;
-    /**
-     * Converts euler angles (x, y, z) in degrees into a quaternion
-     * The error is guaranteed to be less than 0.001.
-     * If the first argument is vector3, its values are used as x, y, z angles.
-     *
-     * @param x - rotation around x-axis in degrees or vector3 with euler angles in degrees
-     * @param y - rotation around y-axis in degrees
-     * @param z - rotation around z-axis in degrees
-     * @returns quaternion describing an equivalent rotation (231 (YZX) rotation sequence)
-     * @example
-     * ```ts
-     * const q = vmath.euler_to_quat(0, 45, 90);
-     * print(q); // => vmath.quat(0.27059805393219, 0.27059805393219, 0.65328145027161, 0.65328145027161)
-     *
-     * const v = vmath.vector3(0, 0, 90);
-     * print(vmath.euler_to_quat(v)); // => vmath.quat(0, 0, 0.70710676908493, 0.70710676908493)
-     * ```
-     */
-    function euler_to_quat(x: number | Vector3, y: number, z: number): Quaternion;
     /**
      * The resulting matrix is the inverse of the supplied matrix.
      * For ortho-normal matrices, e.g. regular object transformation,

package/generated/window.d.ts

@@ -1,6 +1,4 @@
 /** @noSelfInFile */
-import type { Opaque } from "../src/core-types";
-
 declare global {
   /**
    * Functions and constants to access the window, window event listeners
@@ -58,7 +56,7 @@ declare global {
      *
      * - `window.DIMMING_OFF`
      */
-    function get_dim_mode(): Opaque<"constant">;
+    function get_dim_mode(): number & { readonly __brand: "window.DIMMING_UNKNOWN" } | number & { readonly __brand: "window.DIMMING_ON" } | number & { readonly __brand: "window.DIMMING_OFF" };
     /**
      * This returns the content scale of the current display.
      *
@@ -113,7 +111,7 @@ declare global {
      *
      * - `window.DIMMING_OFF`
      */
-    function set_dim_mode(mode: Opaque<"constant">): void;
+    function set_dim_mode(mode: number & { readonly __brand: "window.DIMMING_ON" } | number & { readonly __brand: "window.DIMMING_OFF" }): void;
     /**
      * Sets a window event listener. Only one window event listener can be set at a time.
      *

package/generated/zlib.d.ts

@@ -28,7 +28,8 @@ declare global {
      * @returns inflated buffer
      * @example
      * ```ts
-     * const data = "\120\94\11\201\200\44\86\0\162\68\133\226\146\162\204\188\116\133\242\204\146\12\133\210\188\228\252\220\130\162\212\226\226\212\20\133\148\196\146\68\61\0\44\67\14\201";
+     * const data =
+     *   "\x78\x5e\x0b\xc9\xc8\x2c\x56\x00\xa2\x44\x85\xe2\x92\xa2\xcc\xbc\x74\x85\xf2\xcc\x92\x0c\x85\xd2\xbc\xe4\xfc\xdc\x82\xa2\xd4\xe2\xe2\xd4\x14\x85\x94\xc4\x92\x44\x3d\x00\x2c\x43\x0e\xc9";
      * const uncompressed_data = zlib.inflate(data);
      * print(uncompressed_data); //> This is a string with uncompressed data.
      * ```

package/index.d.ts

@@ -22,14 +22,13 @@ import "./generated/collectionproxy";
 import "./generated/compute";
 import "./generated/crash";
 import "./generated/factory";
+import "./generated/font";
 import "./generated/go";
 import "./src/go-overloads";
 import "./generated/graphics";
 import "./generated/gui";
 import "./generated/html5";
 import "./generated/http";
-import "./generated/iac";
-import "./generated/iap";
 import "./generated/image";
 import "./generated/json";
 import "./generated/label";
@@ -40,8 +39,8 @@ import "./generated/msg";
 import "./generated/particlefx";
 import "./generated/physics";
 import "./generated/profiler";
-import "./generated/push";
 import "./generated/render";
+import "./src/render-overloads";
 import "./generated/resource";
 import "./generated/socket";
 import "./src/socket-types";
@@ -53,7 +52,6 @@ import "./generated/timer";
 import "./generated/types";
 import "./generated/vmath";
 import "./src/vmath-overloads";
-import "./generated/webview";
 import "./generated/window";
 import "./generated/zlib";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defold-typescript/types",
-  "version": "0.34.0",
+  "version": "0.36.0",
   "description": "TypeScript types for the Defold engine's Lua APIs.",
   "license": "MIT",
   "repository": {
@@ -66,7 +66,12 @@
     "!src/**/*.test.ts",
     "!scripts/**/*.test.ts",
     "!src/**/__snapshots__",
-    "!scripts/lua-types-signature-index.ts"
+    "!scripts/lua-types-signature-index.ts",
+    "!scripts/fidelity-audit.ts",
+    "!scripts/augmentation-namespaces.ts",
+    "!scripts/example-pins.ts",
+    "!scripts/example-surfaces.ts",
+    "!scripts/example-typecheck.ts"
   ],
   "publishConfig": {
     "access": "public"

package/scripts/extension-goldens.ts

@@ -0,0 +1,23 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import type { ModuleManifestEntry } from "./regen";
+
+// Committed declarations the `resolve` emitter must reproduce for the extensions
+// whose ref-docs this repo carries. They are a golden lane, not a surface: no
+// entrypoint, kind index or pinned version imports them. They live in their own
+// module because `resolve` imports `regen.ts` from the published package, which
+// does not ship these root fixtures, so reading them at `regen.ts` load time would
+// break every installed `resolve`.
+export const EXTENSION_GOLDENS_DIR = "extension-goldens";
+
+const PACKAGE_ROOT = resolve(import.meta.dir, "..");
+const EXTENSION_GOLDEN_NAMESPACES = ["iac", "iap", "push", "webview"] as const;
+
+export const EXTENSION_GOLDEN_MANIFEST: readonly ModuleManifestEntry[] =
+  EXTENSION_GOLDEN_NAMESPACES.map((namespace) => ({
+    namespace,
+    doc: JSON.parse(
+      readFileSync(resolve(PACKAGE_ROOT, "fixtures", `${namespace}_doc.json`), "utf8"),
+    ),
+    outFile: `${namespace}.d.ts`,
+  }));

package/scripts/generate-api-signatures.ts

@@ -1,7 +1,14 @@
 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 { generateModuleSignatures, loadApiTargets, loadTargetModules } from "./regen";
+import {
+  generateModuleSignatures,
+  loadApiTargets,
+  loadTargetModules,
+  type ModuleManifestEntry,
+} from "./regen";
+import { loadSignatureFile } from "./signature-store-fs";
 
 const PACKAGE_ROOT = resolve(import.meta.dir, "..");
 const SIGNATURES_PATH = resolve(PACKAGE_ROOT, "api-signatures.json");
@@ -9,6 +16,11 @@ const SIGNATURES_PATH = resolve(PACKAGE_ROOT, "api-signatures.json");
 export interface SignaturesArtifact {
   // version -> symbolIdentityKey -> authoritative TS signature text
   readonly versions: Record<string, Record<string, string>>;
+  // The same axis and keys, carrying each documented slot's rendered type. Kept
+  // parallel rather than folded into `versions` because three consumers
+  // (`api-surface-loader`, `combined-surface`, `version-window`) type that map's
+  // value as a string; a symbol documenting no slot is absent here.
+  readonly slotTypes: Record<string, Record<string, SlotTypes>>;
 }
 
 export interface BuildSignaturesOptions {
@@ -16,9 +28,38 @@ export interface BuildSignaturesOptions {
   readonly registryPath?: string;
 }
 
-function sortObjectKeys(record: Record<string, string>): Record<string, string> {
-  const sorted: Record<string, string> = {};
-  for (const key of Object.keys(record).sort()) sorted[key] = record[key] as string;
+// The authored replacement for a symbol the skip filter withheld, read from the
+// same `signatures/<ns>.json` store the version-prefixed API pages render from.
+// 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 {
+  const store = loadSignatureFile(resolve(packageRoot, "signatures", `${namespace}.json`));
+  const forms = store[fqn]?.signatures ?? [];
+  return forms.length > 0 ? forms.join("\n") : null;
+}
+
+// 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 }[] {
+  if ((entry.skipFunctions ?? []).length === 0) return [];
+  const kept = new Set(
+    generateModuleSignatures(entry).map(({ identity }) => symbolIdentityKey(identity)),
+  );
+  const withheld: { key: string; fqn: string }[] = [];
+  for (const { identity } of generateModuleSignatures({ ...entry, skipFunctions: [] })) {
+    const key = symbolIdentityKey(identity);
+    if (kept.has(key)) continue;
+    const fqn = key.split("\0")[2] as string;
+    withheld.push({ key, fqn });
+  }
+  return withheld;
+}
+
+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;
   return sorted;
 }
 
@@ -27,17 +68,33 @@ export function buildSignaturesArtifact(options: BuildSignaturesOptions = {}): S
   const registryPath = options.registryPath ?? resolve(packageRoot, "api-targets.json");
   const targets = selectCompleteVersionSurfaces(loadApiTargets(registryPath));
   const versions: Record<string, Record<string, string>> = {};
+  const slotTypes: Record<string, Record<string, SlotTypes>> = {};
   for (const target of targets) {
     const version = versionOf(target);
     const perSymbol: Record<string, string> = {};
+    const perSymbolSlots: Record<string, SlotTypes> = {};
     for (const entry of loadTargetModules(target, packageRoot)) {
-      for (const { identity, tsSignature } of generateModuleSignatures(entry)) {
-        perSymbol[symbolIdentityKey(identity)] = tsSignature;
+      for (const signature of generateModuleSignatures(entry)) {
+        const key = symbolIdentityKey(signature.identity);
+        perSymbol[key] = signature.tsSignature;
+        if (Object.keys(signature.slotTypes).length > 0) {
+          perSymbolSlots[key] = sortObjectKeys({ ...signature.slotTypes });
+        }
+      }
+      // 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);
+        if (authored !== null) {
+          perSymbol[key] = authored;
+          delete perSymbolSlots[key];
+        }
       }
     }
     versions[version] = sortObjectKeys(perSymbol);
+    slotTypes[version] = sortObjectKeys(perSymbolSlots);
   }
-  return { versions };
+  return { versions, slotTypes };
 }
 
 function biomeFormatJson(raw: string): string {
@@ -47,7 +104,14 @@ function biomeFormatJson(raw: string): string {
   if (out.exitCode !== 0) {
     throw new Error(`biome format failed: ${out.stderr.toString()}`);
   }
-  return out.stdout.toString();
+  const formatted = out.stdout.toString();
+  // Biome exits 0 and emits nothing for input it declined to read (a payload over
+  // `files.maxSize` is reported only on stderr), which would otherwise serialize
+  // the artifact as an empty file.
+  if (formatted.length === 0) {
+    throw new Error(`biome format produced no output: ${out.stderr.toString()}`);
+  }
+  return formatted;
 }
 
 export function serializeSignaturesArtifact(artifact: SignaturesArtifact): string {

package/scripts/materialize-version.ts

@@ -15,7 +15,12 @@ import {
   resolveTargetModules,
 } from "./regen";
 
-export { RUNTIME_KIND_MANIFEST, SRC_AUGMENTATION_MODULES, targetKindManifest } from "./regen";
+export {
+  RESTRICTED_SRC_AUGMENTATIONS,
+  RUNTIME_KIND_MANIFEST,
+  SRC_AUGMENTATION_MODULES,
+  targetKindManifest,
+} from "./regen";
 
 // The surface's own `core-types` module: a re-export of the installed package's,
 // so every declaration in the surface reaches the brand types through a
@@ -26,6 +31,10 @@ export interface RenderMaterializedKindIndexOptions {
   readonly kind: string;
   readonly universalModules: readonly string[];
   readonly restrictedModule: string | null;
+  // The `src/*` augmentations this kind earns because they re-open the very
+  // namespace the kind is restricted to. They sit outside `universalModules`
+  // precisely so no other kind imports them.
+  readonly restrictedAugmentations?: readonly string[];
   // Set for a kind built from the target's own editor documents. It replaces
   // the universal set outright — an editor kind is disjoint from the runtime
   // surface, not a narrowing of it.
@@ -54,6 +63,11 @@ export function renderMaterializedKindIndex(opts: RenderMaterializedKindIndexOpt
   if (entry.only === undefined && opts.restrictedModule) {
     lines.push(`import "../${opts.restrictedModule}";`);
   }
+  if (entry.only === undefined) {
+    for (const augmentation of opts.restrictedAugmentations ?? []) {
+      lines.push(`import "../${augmentation}";`);
+    }
+  }
   const from = installedFactoryModule(entry);
   const values = [entry.factory, ...(entry.extraExports ?? [])].join(", ");
   const typeExports = entry.extraTypeExports?.length