@moku-labs/game 0.15.19 → 0.15.23

package/dist/testing.d.mts

@@ -1,7 +1,7 @@
-import { Qn as AnyFlow, Xn as FeaturePlugin, cr as Descriptor, fr as Hint, gr as ClockSource, ir as NodeTable, pr as NodeFx, vr as FakeClock, wr as Json } from "./types-bwefoJES.mjs";
-import { t as createApp } from "./index-Cku9aRz_.mjs";
-import { b as saveOf, v as WithGameState, y as memory } from "./types-DQtBMqRE.mjs";
-import { a as createHeadless, i as ReproResult, n as HeadlessGame, o as runRepro, r as Repro, s as stepFrames, t as HeadlessApp } from "./headless-uUUH54Ij.mjs";
+import { $n as AnyFlow, Tr as Json, Zn as FeaturePlugin, _r as ClockSource, ar as NodeTable, lr as Descriptor, mr as NodeFx, pr as Hint, yr as FakeClock } from "./types-CHmCFReJ.mjs";
+import { t as createApp } from "./index-CHI7dTc9.mjs";
+import { b as saveOf, v as WithGameState, y as memory } from "./types-DwREs5vb.mjs";
+import { a as createHeadless, i as ReproResult, n as HeadlessGame, o as runRepro, r as Repro, s as stepFrames, t as HeadlessApp } from "./headless-DIbfzWkr.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/plugins/clock/fake.d.ts

package/dist/testing.mjs

@@ -1,7 +1,7 @@
-import { $t as exit, Qt as refuseStart, m as flattenFeatures, nn as type, t as createApp } from "./src-CXfBuKpl.mjs";
+import { $t as refuseStart, en as exit, m as flattenFeatures, rn as type, t as createApp } from "./src-hVe3f8GV.mjs";
 import { n as saveOf, t as memory } from "./memory-CWlqhS7l.mjs";
 import { t as fakeClock } from "./fake-6mazmHK3.mjs";
-import { i as stepFrames, r as runRepro, t as createHeadless } from "./headless-BA6ffzqD.mjs";
+import { i as stepFrames, r as runRepro, t as createHeadless } from "./headless-Bxxl_mQX.mjs";
 //#region src/testing/fake-fx.ts
 /** The node path a refused `fx.start` names when the test gives none. */
 const defaultPath = "test";

package/dist/{types-rr56N0Ab.d.mts → types-9xAh1wGm.d.mts}

@@ -1,5 +1,5 @@
-import { $r as Events$2, $t as Api$3, An as ReducedMotion, Br as Events$5, Cn as Ease, Cr as Events$3, D as FilterSlotInputs, Dn as NumericFields, E as FilterSlot, En as MotionHandle, K as Api$4, Mn as TrackSegment, O as SyncApi, Pn as Api$2, Q as PixiTexture, Wr as Api$1, X as PixiModule, Y as PixiFilter, Z as PixiSprite, cr as Descriptor, dn as Entity, ei as Require, in as AnyComponent, jn as TrackOptions, ln as ComponentType, lt as FilterCache, on as AnyComponentValue, s as Events$1, sn as ComponentHandle, sr as TypeTag, st as Point, t as Api$5, v as Events$4, wr as Json, xr as Api$6 } from "./types-bwefoJES.mjs";
-import { N as InputApi, R as I18nApi, X as StylesState, c as UiNode, i as Finding, l as LayoutState, n as ElementChange, o as JsxState, r as ElementMotion, w as TextApi } from "./types-4T4QTU48.mjs";
+import { $ as PixiTexture, D as FilterSlot, Dn as MotionHandle, Fn as Api$2, Gr as Api$1, Mn as TrackOptions, Nn as TrackSegment, O as FilterSlotInputs, On as NumericFields, Q as PixiSprite, Sr as Api$6, Tr as Json, Vr as Events$5, X as PixiFilter, Z as PixiModule, an as AnyComponent, cn as ComponentHandle, cr as TypeTag, ct as Point, ei as Events$2, en as Api$3, fn as Entity, jn as ReducedMotion, k as SyncApi, lr as Descriptor, q as Api$4, s as Events$1, sn as AnyComponentValue, t as Api$5, ti as Require, un as ComponentType, ut as FilterCache, wn as Ease, wr as Events$3, y as Events$4 } from "./types-CHmCFReJ.mjs";
+import { N as InputApi, R as I18nApi, X as StylesState, c as UiNode, i as Finding, l as LayoutState, n as ElementChange, o as JsxState, r as ElementMotion, w as TextApi } from "./types-DmGs6x0c.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 
@@ -2984,11 +2984,12 @@ type UiApi = {
    */
   find(key: string): Entity | undefined;
   /**
-   * Reads the live screen against the five rules: a tap target under `tapTargetPt` at the size
+   * Reads the live screen against the six rules: a tap target under `tapTargetPt` at the size
    * it is drawn (a `fit: "contain"` on it or above it shrinks it), a text that does not fit its
    * box in some registered locale, an absolute element with no `reason`, a clipping element
-   * (`scroll`, `overflow: "hidden"`) whose style names a nine-slice it never draws, and a root
-   * element whose style sets a `zIndex` it ignores. Never throws; empty when nothing is mounted.
+   * (`scroll`, `overflow: "hidden"`) whose style names a nine-slice it never draws, a style that
+   * is `hollow` with no nine-slice to hollow, and a root element whose style sets a `zIndex` it
+   * ignores. Never throws; empty when nothing is mounted.
    *
    * @returns One finding per rule and element.
    * @example
@@ -2997,6 +2998,8 @@ type UiApi = {
    * app.ui.lint(); // [{ rule: "tap-target", key: "cell", detail: "39 x 39 pt" }]
    * // A list styled with a nine-slice: the clip keeps it from drawing.
    * app.ui.lint(); // [{ rule: "nine-slice-clipped", key: "orders", detail: "scroll" }]
+   * // A frame made hollow before its nine-slice was named: there is no rim to draw.
+   * app.ui.lint(); // [{ rule: "hollow-without-nine-slice", key: "memFrost", detail: "stack" }]
    * // A screen root that asks to be drawn over the others: the layer decides that.
    * app.ui.lint(); // [{ rule: "z-index-on-root", key: "board", detail: "zIndex 2" }]
    * ```

package/dist/{types-bwefoJES.d.mts → types-CHmCFReJ.d.mts}

@@ -157,7 +157,7 @@ type AdaptiveRate = {
 type RateMode = "fixed" | "auto" | "forced";
 /**
  * Why the rate is what it is, the reason of the last change: `"start"` (nothing changed it yet), `"display"` (the
- * display rate became known or changed), `"missed"` (drawn frames came late), `"headroom"` (a return after steady
+ * display rate became known or changed), `"missed"` (drawn frames came late for 2 s in a row, at once within 3 s of a step of the rule), `"headroom"` (a return after steady
  * room), `"thermal"` (the native shell reported heat), `"forced"` / `"auto"` (`setRate`).
  *
  * @example
@@ -384,7 +384,7 @@ type Config$8 = {
   /**
    * Adaptive frame rate. `false` (the default): the loop runs at `maxFps`, as before. With `{ floor }` the loop runs
    * at the highest divisor of the display's refresh rate at or below `maxFps`, drops to the next divisor when drawn
-   * frames come late, and returns when there is room again; never below `floor`. Off in a headless app and on a fake
+   * frames come late for 2 s in a row (one late burst, a mount or an upload, never drops it), and returns when there is room again; never below `floor`. Off in a headless app and on a fake
    * clock.
    */
   adaptive: false | AdaptiveRate;
@@ -502,7 +502,8 @@ type Governor = {
   returnTail: number; /** Samples in the return window. */
   returnDrawn: number; /** Late samples in the return window. */
   returnMissed: number; /** Heavy samples in the return window. */
-  returnHeavy: number; /** When the rate or its mode last changed. */
+  returnHeavy: number; /** When the drop window last turned late and stayed late; NaN while it is not. */
+  lateSince: number; /** When the rate or its mode last changed. */
   switchedAt: number; /** When the rule last returned a step up; -Infinity before the first return. */
   lastReturnAt: number; /** The last step of the rule was a return: its first drop judges it. */
   climbed: boolean; /** How long a return waits after a switch, ms. */
@@ -718,7 +719,7 @@ type Api$7 = {
    * ```ts
    * // The settings screen shows the rate the game runs at on this phone.
    * app.time.rate(); // { fps: 120, mode: "auto", reason: "start", displayHz: 120, ladder: [120, 60], thermal: "none", asked: null, heldBy: null, scale: 1 }
-   * // on the memory screen of a weak phone, a second later:
+   * // on the memory screen of a weak phone, a few seconds later (late for 2 s, then the scale and the rate step down):
    * app.time.rate(); // { fps: 60, mode: "auto", reason: "missed", displayHz: 120, ladder: [120, 60], thermal: "none", asked: null, heldBy: null, scale: 0.75 }
    * // a game with maxFps 120 and no adaptive, on a 60 Hz phone:
    * app.time.rate(); // { fps: 60, mode: "fixed", reason: "start", displayHz: 60, ladder: [], thermal: null, asked: 120, heldBy: "panel", scale: 1 }
@@ -763,7 +764,7 @@ type Api$7 = {
    * ```ts
    * // The renderer on a phone, at start:
    * ctx.require(timePlugin).allowScale(0.75); // { fps: 120, …, scale: 1 }
-   * // on the memory screen of a weak phone, half a second later:
+   * // on the memory screen of a weak phone, a few seconds later (late for 2 s in a row):
    * app.time.rate(); // { fps: 120, mode: "auto", reason: "missed", …, scale: 0.75 }
    * // the player picked a resolution in the settings: the renderer takes the scale away from the rule
    * ctx.require(timePlugin).allowScale(1); // { fps: 120, …, scale: 1 }
@@ -7681,6 +7682,15 @@ type HostInternal = {
    * @returns True when it called Pixi.
    */
   renderProbe(container: PixiContainer, target?: PixiRenderTexture): boolean;
+  /**
+   * Puts a texture source on the GPU now with Pixi's public `renderer.texture.initSource(source)`: the GPU texture is
+   * made and the pixels are uploaded, once; a source Pixi made already costs a lookup. Called by the upload queue of
+   * `sync` before the stage pass of a drawn frame. A no-op while nothing draws. What Pixi throws is thrown on: the
+   * caller logs it and counts the source done.
+   *
+   * @param source - The source of a texture `assets` loaded.
+   */
+  initSource(source: PixiTextureSource): void;
   /**
    * Tells whether the stage pass clears the canvas before it draws (`renderer.background.clearBeforeRender`, Pixi's
    * default, which the engine never turns off): only then may a probe draw onto the canvas.
@@ -7911,7 +7921,17 @@ type KeptRecord = {
   depth: number; /** Bytes of s1, s2, s3 (estimate, P6.1). */
   bytes: number; /** A settle retake is owed: the view came to rest off its picture's grid (P2.5). */
   settle: boolean; /** Bytes a refused take asked for; the record is not offered again until they fit (P6.3). */
-  refused: number; /** A view of kind `"Display"` hangs in the subtree; `undefined` until a take attempt walks it (P4.1). */
+  refused: number;
+  /**
+   * The picture was cut to the canvas at its take (F53): a move or another canvas size would show what it left out,
+   * so either takes it again.
+   */
+  cut: boolean;
+  /**
+   * The quad draws the subtree picture itself at the stack's alpha, with no stage 3 (F54): every enabled filter is an
+   * `AlphaFilter` at the canvas resolution.
+   */
+  direct: boolean; /** A view of kind `"Display"` hangs in the subtree; `undefined` until a take attempt walks it (P4.1). */
   displays: boolean | undefined;
 };
 /** One picture of an overlay's range (P7), keyed by the owner overlay's entity. */
@@ -9017,7 +9037,7 @@ type PictureRequest = {
   reject: (error: Error) => void;
 };
 declare namespace types_d_exports$2 {
-  export { AdaptiveScale, Api$1 as Api, AspectRange, BitmapFontData, CaptureOptions, Captured, Config$2 as Config, CountingClasses, CoverFrame, CreateTextureOptions$1 as CreateTextureOptions, DebugApi, DebugSwitches, DemandFrame, DemandModule, DemandReason, DemandState, Deps$2 as Deps, DisplayAdapter, DisplayEntry, DisplaysApi, DrawCounter, Events$2 as Events, FilterCache, FilterSlot, FilterSlotInputs, FiltersApi, FontsApi, FrameColumns, FrameReadResult, FrameReadout, FrameRecord, FrameRing, HitBox, HostApi, HostInternal, HostModule, HostState, HudPartValue, KeptInternal, KeptModule, KeptRange, KeptState, KeptStats, KernelSlice$2 as KernelSlice, LayerEntry, LegendEntry, LongFrameEntry, Modules, MonitorApi, MonitorConfig, MonitorCounts, MonitorDeps, MonitorInternal, MonitorModule, MonitorSections, MonitorState, NineBorders$1 as NineBorders, Orientation, OverlayEventDetail, OverlayLevelValue, OverlayMode, OverlayPhase, OverlayReport, OverlayValue, OverlayWhat, PassKind, PassRecord, PerfCause, PerfChange, PerfChangeEntry, PerfCollectorLine, PerfCounts, PerfDisplay, PerfEventLine, PerfEventName, PerfGapLine, PerfHeaderLine, PerfLogLine, PerfLongFrameLine, PerfMarkLine, PerfMeasured, PerfMonitorApi, PerfSampleLine, PerfSpikeLine, PerfStartupLine, PerfTelemetryLine, PerfThermalLine, PictureRect, PixiApplication, PixiBitmapFont, PixiBounds, PixiContainer, PixiFilter, PixiFilterManager, PixiGraphics, PixiMatrix, PixiModule, PixiNineSliceSprite, PixiRectangle, PixiRenderTexture, PixiSprite, PixiTexture, Point, PoolTrim, PoolTrimDetail, ProblemEventDetail, ProblemRule, Rect, RenderStats, RendererCtx, RendererKind, SafeArea, ShaderEventDetail, ShaderWhat, SliceFrame, State$2 as State, SyncApi, SyncCounts, SyncInternal, SyncModule, SyncState, TeardownScope, TextureProvider, TextureUsage, TexturesApi, Under, View, ViewKind, ViewportApi, ViewportInternal, ViewportModule, ViewportSize, ViewportState, WarmDetail };
+  export { AdaptiveScale, Api$1 as Api, AspectRange, BitmapFontData, CaptureOptions, Captured, Config$2 as Config, CountingClasses, CoverFrame, CreateTextureOptions$1 as CreateTextureOptions, DebugApi, DebugSwitches, DemandFrame, DemandModule, DemandReason, DemandState, Deps$2 as Deps, DisplayAdapter, DisplayEntry, DisplaysApi, DrawCounter, Events$2 as Events, FilterCache, FilterSlot, FilterSlotInputs, FiltersApi, FontsApi, FrameColumns, FrameReadResult, FrameReadout, FrameRecord, FrameRing, HitBox, HostApi, HostInternal, HostModule, HostState, HudPartValue, KeptInternal, KeptModule, KeptRange, KeptState, KeptStats, KernelSlice$2 as KernelSlice, LayerEntry, LegendEntry, LongFrameEntry, Modules, MonitorApi, MonitorConfig, MonitorCounts, MonitorDeps, MonitorInternal, MonitorModule, MonitorSections, MonitorState, NineBorders$1 as NineBorders, Orientation, OverlayEventDetail, OverlayLevelValue, OverlayMode, OverlayPhase, OverlayReport, OverlayValue, OverlayWhat, PassKind, PassRecord, PerfCause, PerfChange, PerfChangeEntry, PerfCollectorLine, PerfCounts, PerfDisplay, PerfEventLine, PerfEventName, PerfGapLine, PerfHeaderLine, PerfLogLine, PerfLongFrameLine, PerfMarkLine, PerfMeasured, PerfMonitorApi, PerfSampleLine, PerfSpikeLine, PerfStartupLine, PerfTelemetryLine, PerfThermalLine, PictureRect, PixiApplication, PixiBitmapFont, PixiBounds, PixiContainer, PixiFilter, PixiFilterManager, PixiGraphics, PixiMatrix, PixiMesh, PixiModule, PixiNineSliceSprite, PixiRectangle, PixiRenderTexture, PixiSprite, PixiTexture, PixiTextureSource, Point, PoolTrim, PoolTrimDetail, ProblemEventDetail, ProblemRule, Rect, RenderStats, RendererCtx, RendererKind, SafeArea, ShaderEventDetail, ShaderWhat, SliceFrame, State$2 as State, SyncApi, SyncCounts, SyncInternal, SyncModule, SyncState, TeardownScope, TextureProvider, TextureUsage, TexturesApi, Under, View, ViewKind, ViewportApi, ViewportInternal, ViewportModule, ViewportSize, ViewportState, WarmDetail };
 }
 /**
  * The part of Pixi the engine uses: the classes `sync` builds views from (a `Rectangle` frames the
@@ -9031,7 +9051,8 @@ declare namespace types_d_exports$2 {
  * batched distance-field text `host` installs: Pixi's `Batcher` with its geometry and buffers, the bitmap text pipe
  * and the batcher pipe it subclasses, and the WGSL and GLSL shader pieces of the batch's SDF shader, and the WebGPU
  * render target system with its adaptor, the pipeline system and the stencil system the lazy canvas pass of `host`
- * subclasses or registers again (`host/render-pass.ts`). The module object
+ * subclasses or registers again (`host/render-pass.ts`), and the mesh and its geometry the rim-only nine-slice of
+ * `sync` is drawn with (`sync/hollow.ts`). The module object
  * never arrives through a static import: `config.loadPixi()` returns it, so a game without a screen carries no
  * Pixi in its bundle.
  *
@@ -9047,7 +9068,7 @@ declare namespace types_d_exports$2 {
  * pixi.defaultFilterVert.startsWith("in vec2 aPosition;"); // true
  * ```
  */
-type PixiModule = Pick<typeof import("pixi.js"), "AlphaFilter" | "Application" | "Batcher" | "BatcherPipe" | "BitmapFont" | "BitmapText" | "BitmapTextPipe" | "BlurFilter" | "Bounds" | "Buffer" | "BufferUsage" | "Cache" | "ColorMatrixFilter" | "Container" | "DefaultBatcher" | "DisplacementFilter" | "ExtensionType" | "Filter" | "FilterSystem" | "Geometry" | "GlProgram" | "GlTextureSystem" | "GpuBatchAdaptor" | "GpuEncoderSystem" | "GpuGraphicsAdaptor" | "GpuProgram" | "GpuRenderTargetAdaptor" | "GpuRenderTargetSystem" | "GpuStencilSystem" | "GpuTextureSystem" | "Graphics" | "Matrix" | "NineSliceSprite" | "NoiseFilter" | "Particle" | "ParticleContainer" | "PipelineSystem" | "Rectangle" | "RenderGroupPipe" | "RenderTexture" | "Shader" | "Sprite" | "Texture" | "TexturePool" | "UniformGroup" | "bitmapFontTextParser" | "bitmapFontXMLStringParser" | "colorBit" | "colorBitGl" | "compileHighShaderGlProgram" | "compileHighShaderGpuProgram" | "defaultFilterVert" | "extensions" | "generateTextureBatchBit" | "generateTextureBatchBitGl" | "getBatchSamplersUniformGroup" | "mSDFBit" | "mSDFBitGl" | "roundPixelsBit" | "roundPixelsBitGl">;
+type PixiModule = Pick<typeof import("pixi.js"), "AlphaFilter" | "Application" | "Batcher" | "BatcherPipe" | "BitmapFont" | "BitmapText" | "BitmapTextPipe" | "BlurFilter" | "Bounds" | "Buffer" | "BufferUsage" | "Cache" | "ColorMatrixFilter" | "Container" | "DefaultBatcher" | "DisplacementFilter" | "ExtensionType" | "Filter" | "FilterSystem" | "Geometry" | "GlProgram" | "GlTextureSystem" | "GpuBatchAdaptor" | "GpuEncoderSystem" | "GpuGraphicsAdaptor" | "GpuProgram" | "GpuRenderTargetAdaptor" | "GpuRenderTargetSystem" | "GpuStencilSystem" | "GpuTextureSystem" | "Graphics" | "Matrix" | "Mesh" | "MeshGeometry" | "NineSliceSprite" | "NoiseFilter" | "Particle" | "ParticleContainer" | "PipelineSystem" | "Rectangle" | "RenderGroupPipe" | "RenderTexture" | "Shader" | "Sprite" | "Texture" | "TexturePool" | "UniformGroup" | "bitmapFontTextParser" | "bitmapFontXMLStringParser" | "colorBit" | "colorBitGl" | "compileHighShaderGlProgram" | "compileHighShaderGpuProgram" | "defaultFilterVert" | "extensions" | "generateTextureBatchBit" | "generateTextureBatchBitGl" | "getBatchSamplersUniformGroup" | "mSDFBit" | "mSDFBitGl" | "roundPixelsBit" | "roundPixelsBitGl">;
 /**
  * One Pixi application: renderer, canvas and stage.
  */
@@ -9069,6 +9090,10 @@ type PixiSprite = InstanceType<PixiModule["Sprite"]>;
  * A Pixi nine-slice sprite.
  */
 type PixiNineSliceSprite = InstanceType<PixiModule["NineSliceSprite"]>;
+/**
+ * A Pixi mesh: what the rim-only nine-slice of a `NineSlice` with `hollow: true` is drawn with.
+ */
+type PixiMesh = InstanceType<PixiModule["Mesh"]>;
 /**
  * A Pixi graphics object: what a `Shape` component is drawn with, and what clips its children.
  */
@@ -9077,6 +9102,11 @@ type PixiGraphics = InstanceType<PixiModule["Graphics"]>;
  * A Pixi texture. `assets` owns its lifetime; the renderer only makes and destroys it on request.
  */
 type PixiTexture = InstanceType<PixiModule["Texture"]>;
+/**
+ * The source of a Pixi texture: the pixels the GPU holds once, shared by every slice of an atlas page. What the
+ * upload queue of `sync.textures.upload` hands to Pixi's texture system.
+ */
+type PixiTextureSource = PixiTexture["source"];
 /**
  * A texture Pixi renders into: what a kept picture is drawn into, engine-owned and destroyed by the engine.
  */
@@ -9206,6 +9236,8 @@ type AdaptiveScale = {
  * createApp({ pluginConfigs: { renderer: { mount: "#game", keptMb: 32 } } }); // a game with small art
  * // A short splash: two probe draws a frame create the pipelines sooner.
  * createApp({ pluginConfigs: { renderer: { mount: "#game", onDemand: true, warm: 2 } } });
+ * // A desktop game with a fast GPU: `assets.warm` puts two textures a drawn frame on the GPU instead of one.
+ * createApp({ pluginConfigs: { renderer: { mount: "#game", uploads: 2 } } });
  * // A game whose art must stay sharp: the adaptive frame rate drops the rate, never the resolution.
  * createApp({ pluginConfigs: { renderer: { mount: "#game", adaptiveScale: false } } });
  * ```
@@ -9255,6 +9287,22 @@ type Config$2 = {
    * created in the first frame that draws with it, as before. A whole number from 0 to 16; default 1.
    */
   warm: number;
+  /**
+   * Textures `sync.textures.upload` (what `assets.warm` calls) puts on the GPU per drawn frame, before the stage pass,
+   * so the frame that first shows them does not upload them all at once. One upload costs about 9 ms on a Galaxy A26
+   * whatever its size (median, 41 ms at worst): the show frame of 6 cold textures (9.4 MB) took 55 ms there, 8 ms with
+   * them uploaded before. So the budget counts textures, not bytes. 0 turns the queue off: `upload` answers false and
+   * the first draw of a texture uploads it, as before. A whole number from 0 to 8; default 1.
+   *
+   * @example
+   * ```ts
+   * // The memory screen's 6 textures, warmed while the board still shows: 3 drawn frames at 2 a frame.
+   * const app = createApp({ pluginConfigs: { renderer: { mount: "#game", uploads: 2 } } });
+   * await app.start();
+   * await app.assets.warm("ep01.memory"); // resolves after the third drawn frame
+   * ```
+   */
+  uploads: number;
   /**
    * The render scale of the adaptive frame rate on a GPU-bound screen: `{ floor: 0.75, devices: "phone" }` by default,
    * `false` keeps the resolution. Needs `time.adaptive`. A player's `monitor.setResolution` wins over it. Every change
@@ -9539,7 +9587,8 @@ type SpriteValue = {
  * strokes the bounds and the four cut lines over the panel: cyan, red when the corners overlap or
  * the texture is missing. `clip` masks the children of the entity to the `width × height` box,
  * the same rule as `Shape.clip`: the mask is a filled rectangle and is never drawn, and the panel
- * itself is never masked. `alpha` fades the panel and the entity's children.
+ * itself is never masked. `alpha` fades the panel and the entity's children. `hollow` draws the
+ * rim alone: the eight border pieces, never the centre.
  *
  * @example
  * ```ts
@@ -9555,6 +9604,10 @@ type SpriteValue = {
  * const field: NineSliceValue = {
  *   ...value, texture: "ui.field", width: 480, height: 96, clip: true
  * };
+ * // The frost frame of the memory screen: its rim is drawn, its empty centre costs no pixel.
+ * const frost: NineSliceValue = {
+ *   ...value, texture: "glass.frost", width: 960, height: 1400, hollow: true
+ * };
  * ```
  */
 type NineSliceValue = {
@@ -9565,6 +9618,20 @@ type NineSliceValue = {
   tint: number;
   debug: boolean;
   clip: boolean;
+  /**
+   * Draws the rim alone: the four corners and the four edges of the slicing, never the centre cell, so a frame or a
+   * glass panel whose middle is empty fills no pixel there. The hit box stays the whole `width × height`, and `debug`
+   * and `clip` work as on a filled panel. Absent by default, read as `false`, so a panel that never sets it keeps the
+   * values it had before the field existed.
+   *
+   * @example
+   * ```ts
+   * // A 960 x 1400 frame over the memory board, its slices 48 u wide: 8 rim pieces are drawn, the 864 x 1304 centre
+   * // is not, and a tap in the middle still lands on the frame's entity.
+   * world.ecs.spawn(owner, [Layer({ name: "ui" }), Transform(), NineSlice({ texture: "glass.frost", width: 960, height: 1400, hollow: true })]);
+   * ```
+   */
+  hollow?: boolean;
 };
 /**
  * The escape hatch: the game owns a Pixi object and `sync` only attaches and detaches it.
@@ -9712,16 +9779,9 @@ declare const Sprite: ComponentType<SpriteValue>;
 /**
  * A stretchable panel, sized in reference units, with its own alpha and tint. `debug: true` draws
  * the slice outline over it. `clip: true` masks the children of the entity to the panel box.
+ * `hollow: true` draws its rim alone, never the centre cell.
  */
-declare const NineSlice$1: ComponentType<{
-  texture: string;
-  width: number;
-  height: number;
-  alpha: number;
-  tint: number;
-  debug: boolean;
-  clip: boolean;
-}>;
+declare const NineSlice$1: ComponentType<NineSliceValue>;
 /**
  * The entity this view moves with. `0` means no parent.
  */
@@ -10084,6 +10144,29 @@ type TexturesApi = {
    * ```
    */
   invalidate(keys: readonly string[]): void;
+  /**
+   * Puts textures on the GPU before a screen shows them: each texture's source is queued once and uploaded with Pixi's
+   * `renderer.texture.initSource` before the stage pass of a drawn frame, `renderer.uploads` a frame (one by default),
+   * and the renderer asks for the next frame while sources wait. The slices of one atlas page share its source, so the
+   * page is uploaded once. On a Galaxy A26 one upload costs about 9 ms whatever its size: the frame that showed 6 cold
+   * textures took 55 ms, 8 ms once they were uploaded before. Answers `true` once every source of this call went
+   * through, at once when they all did on this device; `false` at once while nothing draws (headless, a lost device)
+   * or with `uploads: 0`, and `false` when the renderer stops or the device is lost before the queue reached them. A
+   * source whose upload throws is logged (`renderer:upload-failed`) and counted done: its first draw uploads it, as
+   * before. A source destroyed while it waits is skipped. The renderer never destroys a texture it was handed.
+   *
+   * @param textures - The textures; `assets` hands every texture and page of a bundle it loaded.
+   * @returns Whether every source is on the GPU.
+   * @example
+   * ```ts
+   * // `assets.warm("ep01.memory")`: the bundle is loaded; its 6 textures go to the GPU while the board still shows.
+   * const renderer = ctx.require(rendererPlugin);
+   * const textures = [...record.textures.values(), ...record.pages.values()];
+   * const uploaded = await renderer.sync.textures.upload(textures); // true 6 drawn frames later (uploads: 1)
+   * await renderer.sync.textures.upload(textures); // true at once: they are on this device already
+   * ```
+   */
+  upload(textures: readonly PixiTexture[]): Promise<boolean>;
 };
 /**
  * The display registry a plugin above extends, `app.renderer.sync.displays`. `Sprite`,
@@ -10720,6 +10803,14 @@ type SyncInternal = {
    * @returns True when it drew a probe in this frame: the frame is then no sample of the adaptive rate.
    */
   warmStep(): boolean;
+  /**
+   * Uploads up to `renderer.uploads` queued texture sources (F60), in a drawn frame, right after the warm-up's probes
+   * and before the stage pass. Asks for the next frame while sources wait. One compare and no allocation while the
+   * queue is empty.
+   *
+   * @returns True when it uploaded a source in this frame: the frame is then no sample of the adaptive rate.
+   */
+  uploadStep(): boolean;
   /**
    * Subscribes to the end of a warm-up run: the queue became empty (the monitor of an agent build writes the `warm`
    * event line). Emptied by `stopSync`.
@@ -10838,6 +10929,60 @@ type WarmState = {
   reported: Set<unknown>;
   listeners: WarmListener[];
 };
+/**
+ * One call of `textures.upload` that waits: how many of its sources are still queued, and its answer. Not public.
+ */
+type UploadWaiter = {
+  left: number;
+  resolve: (ok: boolean) => void;
+};
+/**
+ * The texture upload queue (F60): the sources not yet uploaded from `head` on, emptied when the head reaches the end
+ * (the warm-up's pattern); for each queued source the calls that wait for it; the sources uploaded on this device. A
+ * step with an empty queue reads two numbers. Not public.
+ */
+type UploadState = {
+  /** The sources to upload, from `head` on; each queued once. */queue: PixiTextureSource[];
+  head: number;
+  /**
+   * The calls each queued source is waited for by, in call order: a source in it is in the queue, and every call that
+   * waits is in it under one of its sources. Answered `false` when the renderer stops or the device is lost.
+   */
+  waiting: Map<PixiTextureSource, UploadWaiter[]>;
+  /**
+   * The sources that went through `initSource` on this device, or threw there: a call naming only these answers at
+   * once.
+   */
+  done: WeakSet<PixiTextureSource>;
+};
+/**
+ * What a nine-slice view's object offers `sync`, whichever class draws it: Pixi's `NineSliceSprite`, or the engine's
+ * rim-only mesh of a `hollow` one (`hollow.ts`). The six numbers rebuild the panel when written, the tint and the
+ * texture are written as on a sprite. Not public.
+ */
+type SliceLike = PixiContainer & {
+  leftWidth: number;
+  topHeight: number;
+  rightWidth: number;
+  bottomHeight: number;
+  width: number;
+  height: number;
+  tint: number;
+  texture: PixiTexture;
+};
+/**
+ * The engine's rim-only nine-slice (F59): a Pixi `Mesh` of 16 vertices and 48 indices, the eight border cells of the
+ * slicing and never the centre, driven through the same numbers as a `NineSliceSprite`. `hollow` tells it apart. Not
+ * public.
+ */
+type HollowSlice = SliceLike & {
+  readonly hollow: true;
+};
+/**
+ * The class of the rim-only nine-slice, made once over the Pixi module the renderer loaded (Pixi arrives lazily, so
+ * the class cannot be declared at import). Built with the texture it draws first. Not public.
+ */
+type HollowClass = new (texture: PixiTexture) => HollowSlice;
 /**
  * Where the overlay step's event lines go: the monitor's `event`. Private to the renderer.
  */
@@ -11012,7 +11157,9 @@ type SyncState = {
    * view, so a still frame walks no entry.
    */
   viewlessEntries: boolean; /** The pipeline warm-up (F4). */
-  warm: WarmState;
+  warm: WarmState; /** The texture upload queue (F60). */
+  upload: UploadState; /** The class of the rim-only nine-slice (F59), made at the first hollow view over the loaded Pixi module. */
+  hollowClass: HollowClass | undefined;
   /**
    * The kind of each Pixi filter a slot named, for the performance log of an agent build; a
    * blur's two passes are filters of their own and are in it too. Empty in a production build.
@@ -11410,7 +11557,7 @@ type RunContext = {
   signal: AbortSignal;
 };
 declare namespace types_d_exports {
-  export { Api, AssetKind, AssetStamps, AssetsCtx, AssetsIo, AtlasFrame, AtlasPage, AudioAsset, AudioMime, BundleCompanion, BundleMap, BundleRecord, BundleRelease, BundleSpec, BundleUsage, Config, CreateTextureOptions, DecodedImage, DefineBundles, Deps, Events, FetchResponse, FlowRest, FontAsset, FontPage, HotSwap, Inflight, KernelSlice, LoadBundles, LoadReason, LoadResult, LoadedAssets, LoadedFont, Manifest, ManifestBundle, ManifestFile, NineBorders, NineSlice, PreloadQueue, State, Texture, Tier, Usage };
+  export { Api, AssetKind, AssetStamps, AssetsCtx, AssetsIo, AtlasFrame, AtlasPage, AudioAsset, AudioMime, BundleCompanion, BundleMap, BundleRecord, BundleRelease, BundleSpec, BundleUsage, Config, CreateTextureOptions, DecodedImage, DefineBundles, Deps, Events, FetchResponse, FlowRest, FontAsset, FontPage, HotSwap, Inflight, KernelSlice, LoadBundles, LoadReason, LoadResult, LoadedAssets, LoadedFont, Manifest, ManifestBundle, ManifestFile, NineBorders, NineSlice, PreloadQueue, ReadyBundles, State, Texture, Tier, Usage, WarmEntry };
 }
 /**
  * When a bundle is loaded. `boot` and `core` stay for the whole session, `scene` and `feature`
@@ -11808,6 +11955,18 @@ type DefineBundles<Key extends string> = (map: Partial<Record<Key, BundleSpec>>)
  * ```
  */
 type LoadBundles<Key extends string> = (bundle: Key | readonly Key[]) => Descriptor<LoadResult | undefined>;
+/**
+ * The `ready` descriptor helper bound to the bundle keys of one game (F52). The descriptor resolves
+ * `true` when every bundle is loaded and on the GPU, `false` while the node should rest until the
+ * inbox event `ready`, or `undefined` in an app without `assets`.
+ *
+ * @example
+ * ```ts
+ * const readyGameBundle: ReadyBundles<"board" | "board.chains"> = ready;
+ * readyGameBundle("board"); // { kind: "ready", payload: { bundles: ["board"] } }
+ * ```
+ */
+type ReadyBundles<Key extends string> = (bundle: Key | readonly Key[]) => Descriptor<boolean | undefined>;
 /**
  * What the `load` effect resolves with, so a loading node can write its own progress.
  *
@@ -11912,6 +12071,15 @@ type PreloadQueue = {
   bundles: string[];
   controller: AbortController;
 };
+/**
+ * One warm of a bundle (F60): the promise every caller of `warm` joins, and `done` once it
+ * resolved, so the `ready` effect answers without waiting. Dropped when the bundle unloads, and
+ * when the warm fails, so the next call tries again.
+ */
+type WarmEntry = {
+  promise: Promise<void>;
+  done: boolean;
+};
 /**
  * What the keys watch of `moku-game dev` knows about the asset files of a game: the default export
  * of the generated `.moku/assets-stamp.ts`. The dev hot swap compares it with the map it applied
@@ -11968,8 +12136,8 @@ type State = {
   useCounter: number; /** Keys already reported missing, so one key warns and starts its background load once. */
   warned: Set<string>;
   /**
-   * `onEnter`, the `load` handler, the texture provider, the start and the end of an exit in `world`, and the system
-   * `assets.leave` of phase `sync`.
+   * `onEnter`, the `load` and `ready` handlers, the texture provider, the start and the end of an exit in `world`,
+   * and the system `assets.leave` of phase `sync`.
    */
   removers: Array<() => void>; /** The `files` map of the stamp the dev hot swap applied last. `undefined` until the first swap. */
   stamps: Readonly<Record<string, string>> | undefined; /** The running dev hot swap. The next one waits for it, so two swaps never overlap. */
@@ -11983,6 +12151,12 @@ type State = {
   exiting: number; /** Registered companions, in registration order. */
   companions: BundleCompanion[]; /** A live rest was announced; the arriving node's `load` stage runs the release. */
   restPending: boolean;
+  /**
+   * Bundles whose warm for a `ready` effect failed (not an abort): `ready` counts them as there, so a node never
+   * hangs on them, until a later load of the bundle succeeds (F52).
+   */
+  readyFailed: Set<string>; /** One running or finished warm per bundle, joined by a second `warm`; dropped when the bundle unloads (F60). */
+  warmed: Map<string, WarmEntry>;
 };
 /**
  * What `usage()` reports about one loaded bundle.
@@ -12110,6 +12284,27 @@ type Api = {
    * ```
    */
   load(bundle: string): Promise<void>;
+  /**
+   * Puts the textures of a bundle on the GPU before a scene shows them (F60): loads the bundle when
+   * it is not loaded, then hands every texture and atlas page of it to
+   * `renderer.sync.textures.upload`, which uploads `renderer.uploads` of them a drawn frame. A
+   * second call joins the running or finished warm of the same bundle; an unload forgets it, so a
+   * reload warms again. It resolves also when the renderer could not upload (no device,
+   * `uploads: 0`, a stop): the first draw uploads then, as before. Headless it resolves at once,
+   * as `load` does. The `ready` effect waits for it.
+   *
+   * @param bundle - Name of a bundle of the manifest.
+   * @returns A promise that resolves once the bundle is loaded and its textures went to the GPU.
+   * @throws {Error} When the manifest has no such bundle, and when a file fails to load.
+   * @example
+   * ```ts
+   * // Outside a node: the board's art goes to the GPU while the menu still shows.
+   * await app.assets.warm("ep01.board"); // the board's textures are on the GPU, 1 per drawn frame
+   * app.assets.isLoaded("ep01.board"); // true
+   * await app.assets.warm("ep01.board"); // at once: the same warm, nothing is uploaded twice
+   * ```
+   */
+  warm(bundle: string): Promise<void>;
   /**
    * Destroys the textures of a bundle and tells `renderer` that its keys are gone; every
    * companion's `unload` runs. A pinned bundle and the tiers `boot` and `core` are refused with a
@@ -12337,4 +12532,4 @@ type BundleCompanion = {
   unload(bundle: string): void;
 };
 //#endregion
-export { PoolTrim as $, Bookmark as $n, Events$8 as $r, Api$2 as $t, HudPart as A, ReducedMotion as An, ProviderCall as Ar, PerfCounts as At, SpriteOptions as B, Position as Bn, Events$6 as Br, PerfSampleLine as Bt, State$1 as C, Ease as Cn, Events$5 as Cr, PROBLEM_RULES as Ct, FilterSlotInputs as D, NumericFields as Dn, types_d_exports$6 as Dr, PerfChange as Dt, FilterSlot as E, MotionHandle as En, State$6 as Er, PerfCause as Et, OverlayValue as F, BundlesOf as Fn, StoreApi as Fr, PerfHeaderLine as Ft, AdaptiveScale as G, exit as Gn, Config$8 as Gr, PoolTrimDetail as Gt, Transform as H, TextStylesOf as Hn, State$7 as Hr, PerfStartupLine as Ht, Parent as I, Config$4 as In, RngApi as Ir, PerfLogLine as It, MonitorConfig as J, type as Jn, State$8 as Jr, SHADER_WHATS as Jt, Api$1 as K, slot as Kn, FrameRate as Kr, ProblemEventDetail as Kt, Shape as L, EmitterIdOf as Ln, RngState as Lr, PerfLongFrameLine as Lt, NineSlice$1 as M, TrackSegment as Mn, SaveUnreadableError as Mr, PerfEventLine as Mt, NineSliceValue as N, ViewHandle as Nn, Snapshot as Nr, PerfEventName as Nt, SyncApi as O, ProjectionMotion as On, Patch as Or, PerfChangeEntry as Ot, Overlay as P, Api$3 as Pn, SnapshotOf as Pr, PerfGapLine as Pt, PixiTexture as Q, AnyFlow as Qn, Config$9 as Qr, DEMAND_REASONS as Qt, ShapeValue as R, GameTypes as Rn, Api$6 as Rr, PerfMarkLine as Rt, ScenesApi as S, DescriptionNode as Sn, Config$6 as Sr, PERF_LOG_VERSION as St, DebugSwitches as T, MotionCause as Tn, Root as Tr, PassRecord as Tt, TransformValue as U, types_d_exports$4 as Un, types_d_exports$7 as Ur, PerfTelemetryLine as Ut, SpriteValue as V, State$4 as Vn, PauseReason as Vr, PerfSpikeLine as Vt, sprite as W, defineFlow as Wn, Api$7 as Wr, PerfThermalLine as Wt, PixiModule as X, FeaturePlugin as Xn, Time as Xr, ShaderWhat as Xt, PixiFilter as Y, FeatureDescription as Yn, ThermalReading as Yr, ShaderEventDetail as Yt, PixiSprite as Z, FeatureTree as Zn, types_d_exports$8 as Zr, WarmDetail as Zt, DefineScene as _, ResourceType as _n, Config$5 as _r, MonitorSections as _t, Config as a, AnyComponentType as an, RouteStep as ar, RenderStats as at, SceneDefinition as b, TagType as bn, types_d_exports$5 as br, PERF_CAUSES as bt, LoadBundles as c, ComponentSchema as cn, Descriptor as cr, ViewportSize as ct, Manifest as d, Entity as dn, GuideOptions as dr, FrameReadResult as dt, Require as ei, Config$3 as en, DefineNode as er, State$2 as et, State as f, EntitySnapshot as fn, Hint as fr, FrameReadout as ft, AnySceneProjection as g, QueryTerm as gn, ClockSource as gr, MONITOR_SECTIONS as gt, types_d_exports as h, Narrowed as hn, Api$4 as hr, LongFrameEntry as ht, BundleSpec as i, AnyComponent as in, NodeTable as ir, MonitorCounts as it, HudPartValue as j, TrackOptions as jn, SaveDoc as jr, PerfDisplay as jt, Display as k, ProjectionSpec as kn, PlayerStateProvider as kr, PerfCollectorLine as kt, LoadReason as l, ComponentType as ln, Effect as lr, FilterCache as lt, Usage as m, Mut as mn, Answer as mr, FrameRing as mt, AssetsIo as n, State$3 as nn, FlowState as nr, types_d_exports$2 as nt, DefineBundles as o, AnyComponentValue as on, SceneIdOf as or, Orientation as ot, Tier as p, FrameDiff as pn, NodeFx as pr, FrameRecord as pt, Config$2 as q, to as qn, RateChange as qr, ProblemRule as qt, BundleMap as r, types_d_exports$3 as rn, JournalEntry as rr, Captured as rt, Events as s, ComponentHandle as sn, TypeTag as sr, Point as st, Api as t, Explained as tn, FlowGraph as tr, Under as tt, LoadResult as u, ComponentValue as un, EffectOptions as ur, FrameColumns as ut, Events$1 as v, SystemDefinition as vn, FakeClock as vr, OverlayEventDetail as vt, types_d_exports$1 as w, Motion as wn, Json as wr, PassKind as wt, SceneSpec as x, ChangeHook as xn, Api$5 as xr, PERF_GAP_BUCKETS as xt, LayerMap as y, SystemFor as yn, State$5 as yr, OverlayWhat as yt, Sprite as z, HudKeysOf as zn, Config$7 as zr, PerfMeasured as zt };
+export { PixiTexture as $, AnyFlow as $n, Config$9 as $r, DEMAND_REASONS as $t, Display as A, ProjectionSpec as An, PlayerStateProvider as Ar, PerfCollectorLine as At, Sprite as B, HudKeysOf as Bn, Config$7 as Br, PerfMeasured as Bt, ScenesApi as C, DescriptionNode as Cn, Config$6 as Cr, PERF_LOG_VERSION as Ct, FilterSlot as D, MotionHandle as Dn, State$6 as Dr, PerfCause as Dt, DebugSwitches as E, MotionCause as En, Root as Er, PassRecord as Et, Overlay as F, Api$3 as Fn, SnapshotOf as Fr, PerfGapLine as Ft, sprite as G, defineFlow as Gn, Api$7 as Gr, PerfThermalLine as Gt, SpriteValue as H, State$4 as Hn, PauseReason as Hr, PerfSpikeLine as Ht, OverlayValue as I, BundlesOf as In, StoreApi as Ir, PerfHeaderLine as It, Config$2 as J, to as Jn, RateChange as Jr, ProblemRule as Jt, AdaptiveScale as K, exit as Kn, Config$8 as Kr, PoolTrimDetail as Kt, Parent as L, Config$4 as Ln, RngApi as Lr, PerfLogLine as Lt, HudPartValue as M, TrackOptions as Mn, SaveDoc as Mr, PerfDisplay as Mt, NineSlice$1 as N, TrackSegment as Nn, SaveUnreadableError as Nr, PerfEventLine as Nt, FilterSlotInputs as O, NumericFields as On, types_d_exports$6 as Or, PerfChange as Ot, NineSliceValue as P, ViewHandle as Pn, Snapshot as Pr, PerfEventName as Pt, PixiSprite as Q, FeatureTree as Qn, types_d_exports$8 as Qr, WarmDetail as Qt, Shape as R, EmitterIdOf as Rn, RngState as Rr, PerfLongFrameLine as Rt, SceneSpec as S, ChangeHook as Sn, Api$5 as Sr, PERF_GAP_BUCKETS as St, types_d_exports$1 as T, Motion as Tn, Json as Tr, PassKind as Tt, Transform as U, TextStylesOf as Un, State$7 as Ur, PerfStartupLine as Ut, SpriteOptions as V, Position as Vn, Events$6 as Vr, PerfSampleLine as Vt, TransformValue as W, types_d_exports$4 as Wn, types_d_exports$7 as Wr, PerfTelemetryLine as Wt, PixiFilter as X, FeatureDescription as Xn, ThermalReading as Xr, ShaderEventDetail as Xt, MonitorConfig as Y, type as Yn, State$8 as Yr, SHADER_WHATS as Yt, PixiModule as Z, FeaturePlugin as Zn, Time as Zr, ShaderWhat as Zt, AnySceneProjection as _, QueryTerm as _n, ClockSource as _r, MONITOR_SECTIONS as _t, Config as a, AnyComponent as an, NodeTable as ar, MonitorCounts as at, LayerMap as b, SystemFor as bn, State$5 as br, OverlayWhat as bt, LoadBundles as c, ComponentHandle as cn, TypeTag as cr, Point as ct, Manifest as d, ComponentValue as dn, EffectOptions as dr, FrameColumns as dt, Events$8 as ei, Api$2 as en, Bookmark as er, PoolTrim as et, ReadyBundles as f, Entity as fn, GuideOptions as fr, FrameReadResult as ft, types_d_exports as g, Narrowed as gn, Api$4 as gr, LongFrameEntry as gt, Usage as h, Mut as hn, Answer as hr, FrameRing as ht, BundleSpec as i, types_d_exports$3 as in, JournalEntry as ir, Captured as it, HudPart as j, ReducedMotion as jn, ProviderCall as jr, PerfCounts as jt, SyncApi as k, ProjectionMotion as kn, Patch as kr, PerfChangeEntry as kt, LoadReason as l, ComponentSchema as ln, Descriptor as lr, ViewportSize as lt, Tier as m, FrameDiff as mn, NodeFx as mr, FrameRecord as mt, AssetsIo as n, Explained as nn, FlowGraph as nr, Under as nt, DefineBundles as o, AnyComponentType as on, RouteStep as or, RenderStats as ot, State as p, EntitySnapshot as pn, Hint as pr, FrameReadout as pt, Api$1 as q, slot as qn, FrameRate as qr, ProblemEventDetail as qt, BundleMap as r, State$3 as rn, FlowState as rr, types_d_exports$2 as rt, Events as s, AnyComponentValue as sn, SceneIdOf as sr, Orientation as st, Api as t, Require as ti, Config$3 as tn, DefineNode as tr, State$2 as tt, LoadResult as u, ComponentType as un, Effect as ur, FilterCache as ut, DefineScene as v, ResourceType as vn, Config$5 as vr, MonitorSections as vt, State$1 as w, Ease as wn, Events$5 as wr, PROBLEM_RULES as wt, SceneDefinition as x, TagType as xn, types_d_exports$5 as xr, PERF_CAUSES as xt, Events$1 as y, SystemDefinition as yn, FakeClock as yr, OverlayEventDetail as yt, ShapeValue as z, GameTypes as zn, Api$6 as zr, PerfMarkLine as zt };

package/dist/{types-4T4QTU48.d.mts → types-DmGs6x0c.d.mts}

@@ -1,4 +1,4 @@
-import { $t as Api$2, An as ReducedMotion, Cn as Ease, Dn as NumericFields, En as MotionHandle, K as Api$3, Nn as ViewHandle, On as ProjectionMotion, Pn as Api$1, Tn as MotionCause, U as TransformValue, Wr as Api, an as AnyComponentType, bn as TagType, cr as Descriptor, ct as ViewportSize, dn as Entity, ei as Require, fr as Hint, hr as Api$5, in as AnyComponent, ln as ComponentType, mr as Answer, on as AnyComponentValue, s as Events$1, t as Api$4, wn as Motion, wr as Json, xn as ChangeHook } from "./types-bwefoJES.mjs";
+import { Dn as MotionHandle, En as MotionCause, Fn as Api$1, Gr as Api, On as NumericFields, Pn as ViewHandle, Sn as ChangeHook, Tn as Motion, Tr as Json, W as TransformValue, an as AnyComponent, en as Api$2, fn as Entity, gr as Api$5, hr as Answer, jn as ReducedMotion, kn as ProjectionMotion, lr as Descriptor, lt as ViewportSize, on as AnyComponentType, pr as Hint, q as Api$3, s as Events$1, sn as AnyComponentValue, t as Api$4, ti as Require, un as ComponentType, wn as Ease, xn as TagType } from "./types-CHmCFReJ.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 import { Node, Yoga } from "yoga-layout/load";
@@ -157,7 +157,21 @@ type VisualStyle<Asset extends string = string> = {
    * but `image`, `icon` and `text` takes it; a clipping element (`scroll`, `overflow: "hidden"`)
    * keeps its rectangle, which carries the clip.
    */
-  nineSlice?: Asset; /** Multiplies the colour of a nine-slice or an image. */
+  nineSlice?: Asset;
+  /**
+   * Draws the nine-slice of the style as its rim alone: the eight border pieces, never the
+   * centre, so a frame or a glass panel with an empty middle fills no pixel there. `false` by
+   * default. Does nothing without `nineSlice`; `lint()` reports it as
+   * `hollow-without-nine-slice`. A tap in the middle still lands on the element.
+   *
+   * @example
+   * ```tsx
+   * // The frost frame of the memory screen: its rim is drawn, its centre shows the board under it.
+   * <stack key="memFrost" style={{ nineSlice: "glass.frost", hollow: true, width: 960, height: 1400 }} />;
+   * app.world.ecs.get(app.ui.find("memFrost") ?? 0, NineSlice)?.hollow; // true
+   * ```
+   */
+  hollow?: boolean; /** Multiplies the colour of a nine-slice or an image. */
   tint?: number;
   /**
    * Outlines the nine-slice of the style: its bounds and the four slice lines, cyan, red when
@@ -1741,7 +1755,8 @@ type State = {
    * container drawn under an older count is built again on its next update.
    */
   generation: number; /** Warning keys already written, so a style, a tag, a glyph or a font warns once. */
-  warned: Set<string>; /** The system, the step after the layout flush, the two world hooks and the display adapter. */
+  warned: Set<string>; /** The `"box"` styles a layout measured at a width: a label of one with no box fits its row, it is not outside a layout (F65). */
+  laidOut: Set<string>; /** The system, the step after the layout flush, the two world hooks and the display adapter. */
   removers: Array<() => void>;
 };
 /**
@@ -1760,7 +1775,9 @@ type TextApi = {
    * The size of a piece of text in reference pixels, from the advance table of the style's font.
    * A `Message` is formatted in the current locale first. Never touches a canvas, so the answer
    * is the same in a browser and in plain Bun. Cached per style and resolved string, and per
-   * width for a `"box"` style.
+   * width for a `"box"` style. A call with a width is a layout's (`ui.layout` is the caller it is
+   * meant for): it marks the style as laid out, so a label of it with no box (one that fits its
+   * row) no longer warns `wrap "box" outside layout` (F65).
    *
    * @param content - A plain string, or what `tr` returned.
    * @param style - A registered style name. An unknown one warns once and measures as `body`.
@@ -2685,7 +2702,8 @@ type Element = {
     height: number;
   };
   measuredWidth?: number | undefined; /** True once the text wrapped at its box: from then on `ui` writes its box, 0 when it fits. */
-  boxed?: boolean;
+  boxed?: boolean; /** True once its nine-slice was hollow: from then on `ui` writes `hollow`, false when the style drops it. */
+  hollowed?: boolean;
   basis?: StyleBasis; /** The motions of its hooks that started a `repeat: "forever"` track; made with the first one. */
   endless?: Set<MotionHandle>; /** What its enter hook did at the `Box`, until `ui.enter` keeps the play or plays it again (F49). */
   posed?: PosedEnter | undefined;
@@ -3017,7 +3035,7 @@ type UiNode = {
  * ```
  */
 type Finding = {
-  rule: "tap-target" | "text-overflow" | "absolute-without-reason" | "nine-slice-clipped" | "z-index-on-root";
+  rule: "tap-target" | "text-overflow" | "absolute-without-reason" | "nine-slice-clipped" | "hollow-without-nine-slice" | "z-index-on-root";
   key: string;
   detail: string;
 };

package/dist/{types-DQtBMqRE.d.mts → types-DwREs5vb.d.mts}

@@ -1,7 +1,7 @@
-import { Ar as ProviderCall, In as Config$1, Pr as SnapshotOf, Qn as AnyFlow, Sr as Config, X as PixiModule, Xn as FeaturePlugin, a as Config$3, d as Manifest, gr as ClockSource, jr as SaveDoc, kr as PlayerStateProvider, n as AssetsIo, ot as Orientation, q as Config$2, sr as TypeTag, vr as FakeClock, wr as Json } from "./types-bwefoJES.mjs";
-import { o as AudioContextLike, s as Config$4 } from "./types-rr56N0Ab.mjs";
-import { R as I18nApi, U as StringTable, W as TextKey } from "./types-4T4QTU48.mjs";
-import { ft as platformPlugin, i as screen, mt as PlatformProvider, t as createApp, wt as audioPlugin, xt as effectsPlugin } from "./index-Cku9aRz_.mjs";
+import { $n as AnyFlow, Ar as PlayerStateProvider, Cr as Config, Fr as SnapshotOf, J as Config$2, Ln as Config$1, Mr as SaveDoc, Tr as Json, Z as PixiModule, Zn as FeaturePlugin, _r as ClockSource, a as Config$3, cr as TypeTag, d as Manifest, jr as ProviderCall, n as AssetsIo, st as Orientation, yr as FakeClock } from "./types-CHmCFReJ.mjs";
+import { o as AudioContextLike, s as Config$4 } from "./types-9xAh1wGm.mjs";
+import { R as I18nApi, U as StringTable, W as TextKey } from "./types-DmGs6x0c.mjs";
+import { St as effectsPlugin, Tt as audioPlugin, ht as PlatformProvider, i as screen, pt as platformPlugin, t as createApp } from "./index-CHI7dTc9.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/plugins/model/store/providers/memory.d.ts

package/dist/{types-DMsvVZZT.d.mts → types-L4nVF9Ny.d.mts}

@@ -1,5 +1,5 @@
-import { Nr as Snapshot, wr as Json } from "./types-bwefoJES.mjs";
-import { t as HeadlessApp } from "./headless-uUUH54Ij.mjs";
+import { Pr as Snapshot, Tr as Json } from "./types-CHmCFReJ.mjs";
+import { t as HeadlessApp } from "./headless-DIbfzWkr.mjs";
 import { Log } from "@moku-labs/common/browser";
 
 //#region src/plugins/flow/doors/types.d.ts