@moku-labs/game 0.0.1 → 0.0.3

package/dist/types-DgwbzDLP.d.mts

@@ -0,0 +1,690 @@
+import { St as Api$3, f as SliceFrame, mt as NodeInfo, nn as Require, o as PixiTexture, q as Api$1, t as Api$2, vt as Descriptor } from "./types-Cjf3ywai.mjs";
+import { Log } from "@moku-labs/common/browser";
+import { PluginCtx } from "@moku-labs/core";
+
+//#region src/plugins/assets/types.d.ts
+declare namespace types_d_exports {
+  export { Api, AssetKind, AssetsCtx, AssetsIo, AtlasFrame, AtlasPage, BundleMap, BundleRecord, BundleSpec, BundleUsage, Config, CreateTextureOptions, DecodedImage, DefineBundles, Deps, Events, FetchResponse, FlowRest, FontAsset, FontPage, Inflight, KernelSlice, LoadBundles, LoadReason, LoadResult, LoadedAssets, LoadedFont, Manifest, ManifestBundle, ManifestFile, NineBorders, NineSlice, PreloadQueue, State, Texture, Tier, Usage };
+}
+/**
+ * When a bundle is loaded. `boot` and `core` stay for the whole session, `scene` and `feature`
+ * come and go with the graph, `lazy` is never preloaded.
+ *
+ * @example
+ * ```ts
+ * const tier: Tier = "scene";
+ * ```
+ */
+type Tier = "boot" | "core" | "scene" | "feature" | "lazy";
+/**
+ * What one file of a bundle is. A `.fnt` with its `.png` pages is one `font`, an `.mp3` is
+ * `audio`, everything else is a `texture`. A file of an older manifest that names no kind is a
+ * texture.
+ *
+ * @example
+ * ```ts
+ * const kind: AssetKind = "font";
+ * ```
+ */
+type AssetKind = "texture" | "font" | "audio";
+/**
+ * A GPU texture. `assets` owns its lifetime and never imports Pixi: `renderer` makes and destroys
+ * it, this plugin only says when.
+ */
+type Texture = PixiTexture;
+/**
+ * A decoded image, ready for the upload. `createImageBitmap` produces the first shape.
+ */
+type DecodedImage = ImageBitmap | HTMLImageElement;
+/**
+ * Nine-slice borders in pixels, in the order left, top, right, bottom.
+ *
+ * @example
+ * ```ts
+ * const borders: NineBorders = [48, 48, 48, 48];
+ * ```
+ */
+type NineBorders = readonly [number, number, number, number];
+/**
+ * Options of `io.createTexture`. Same shape as `renderer.sync.textures.create`.
+ *
+ * @example
+ * ```ts
+ * const options: CreateTextureOptions = { nine: [48, 48, 48, 48] };
+ * ```
+ */
+type CreateTextureOptions = {
+  nine?: NineBorders;
+};
+/**
+ * The part of a fetch response the plugin reads: the manifest is `json`, a texture is a `blob`,
+ * a font file is `text` and an audio file stays the raw `arrayBuffer`. The global `Response`
+ * fits it.
+ */
+type FetchResponse = {
+  ok: boolean;
+  status: number;
+  json(): Promise<unknown>;
+  blob(): Promise<Blob>;
+  text(): Promise<string>;
+  arrayBuffer(): Promise<ArrayBuffer>;
+};
+/**
+ * The I/O seam: everything that leaves the plugin. `undefined` in the config means the browser
+ * pair plus `renderer.sync.textures`; a test passes a fake and nothing touches the network or a GPU.
+ *
+ * @example
+ * ```ts
+ * // A unit test serves two files from memory and counts the textures it handed out.
+ * const io: AssetsIo = {
+ *   fetch: async () => ({
+ *     ok: true,
+ *     status: 200,
+ *     json: async () => ({}),
+ *     blob: async () => blob,
+ *     text: async () => 'info face="body"',
+ *     arrayBuffer: async () => new ArrayBuffer(8)
+ *   }),
+ *   decode: async () => bitmap,
+ *   createTexture: () => ({ id: "t1" }) as unknown as Texture,
+ *   sliceTexture: (page, frame) => ({ id: "s1", page, frame }) as unknown as Texture,
+ *   destroyTexture: texture => destroyed.push(texture)
+ * };
+ *
+ * createApp({ plugins: [...screen], pluginConfigs: { assets: { io, manifest } } });
+ * ```
+ */
+type AssetsIo = {
+  /**
+   * Fetches one URL: the manifest, or a file of a bundle.
+   *
+   * @param url - Absolute or root-relative URL.
+   * @param init - Carries the abort signal of the running load.
+   * @param init.signal - Aborts the request when the load is cancelled.
+   * @returns The response.
+   */
+  fetch(url: string, init: {
+    signal: AbortSignal;
+  }): Promise<FetchResponse>;
+  /**
+   * Decodes one image file.
+   *
+   * @param blob - The bytes of the file.
+   * @returns The decoded image.
+   */
+  decode(blob: Blob): Promise<DecodedImage>;
+  /**
+   * Uploads one decoded image to the GPU.
+   *
+   * @param image - The decoded image.
+   * @param options - `nine` becomes the default nine-slice borders of the texture.
+   * @returns The new texture.
+   */
+  createTexture(image: DecodedImage, options?: CreateTextureOptions): Texture;
+  /**
+   * Cuts the texture of one packed file out of its atlas page. The slice shares the page's
+   * source: no pixel is copied. Same shape as `renderer.sync.textures.slice`; the manifest's
+   * `atlas` frame is passed as it is.
+   *
+   * @param page - The page texture, made by `createTexture`.
+   * @param frame - Where the file lies on the page, in page pixels.
+   * @param options - `nine` becomes the default nine-slice borders of the slice.
+   * @returns The new texture over the page's source.
+   */
+  sliceTexture(page: Texture, frame: SliceFrame, options?: CreateTextureOptions): Texture;
+  /**
+   * Frees one texture. A page frees its source too; a slice frees only itself, so the slices of
+   * a bundle go first and its pages after them.
+   *
+   * @param texture - The texture to free.
+   */
+  destroyTexture(texture: Texture): void;
+};
+/**
+ * Nine-slice metadata of one file, as the scanner writes it. Always four numbers: the tags
+ * `{nine=N}`, `{nine=H,V}` and `{nine=L,T,R,B}` all land here.
+ *
+ * @example
+ * ```ts
+ * const nine: NineSlice = { left: 48, top: 48, right: 48, bottom: 48 };
+ * ```
+ */
+type NineSlice = {
+  left: number;
+  top: number;
+  right: number;
+  bottom: number;
+};
+/**
+ * Where a packed file lies: `page` is the id of a page of the same bundle, never a file name, and
+ * the frame is in page pixels. `width` and `height` equal the file's own, so its `nine` stays
+ * valid as it is. The packer writes it; the loader cuts the file out of the page.
+ *
+ * @example
+ * ```ts
+ * const frame: AtlasFrame = { page: "ui/main-0", x: 583, y: 595, width: 256, height: 128 };
+ * ```
+ */
+type AtlasFrame = {
+  page: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+/**
+ * One atlas page of a packed bundle. `id` is `<bundle>/<group>-<index>`, the name an `atlas`
+ * frame uses; `path` is the hashed WebP file, read like the `path` of a file. `mb` is
+ * `width × height × 4 / 1 048 576`: the page carries the cost of every file packed on it.
+ *
+ * @example
+ * ```ts
+ * const page: AtlasPage = {
+ *   id: "ui/main-0",
+ *   path: "ui/main-0-3b1d55a0c9.webp",
+ *   width: 966,
+ *   height: 1365,
+ *   mb: 5.03
+ * };
+ * ```
+ */
+type AtlasPage = {
+  id: string;
+  path: string;
+  width: number;
+  height: number;
+  mb: number;
+};
+/**
+ * One page image of a font. A page has no key of its own: it belongs to the `.fnt` file that
+ * names it, and is loaded and freed with it.
+ *
+ * @example
+ * ```ts
+ * const page: FontPage = {
+ *   path: "features/ui/assets/body_0.png",
+ *   width: 256,
+ *   height: 128,
+ *   mb: 0.125
+ * };
+ * ```
+ */
+type FontPage = {
+  path: string;
+  width: number;
+  height: number;
+  mb: number;
+};
+/**
+ * One file of a bundle. `mb` is what it costs: `width × height × 4` bytes for a texture, the sum
+ * of the pages for a font, the size of the file for audio, and `0` for a texture packed in an
+ * atlas, whose page carries the cost. `kind` is absent for a texture, which is what every
+ * manifest written before fonts and audio carries. A loose file has `path`; a packed texture has
+ * `atlas` and no `path`.
+ *
+ * @example
+ * ```ts
+ * // The dev manifest of the scanner: a loose file.
+ * const loose: ManifestFile = {
+ *   key: "ui.panel",
+ *   path: "features/ui/assets/panel{nine=48}.png",
+ *   width: 256,
+ *   height: 128,
+ *   mb: 0.125,
+ *   nine: { left: 48, top: 48, right: 48, bottom: 48 }
+ * };
+ *
+ * // The packed manifest: the same key, cut out of the page "ui/main-0".
+ * const packed: ManifestFile = {
+ *   key: "ui.panel",
+ *   width: 256,
+ *   height: 128,
+ *   mb: 0,
+ *   nine: { left: 48, top: 48, right: 48, bottom: 48 },
+ *   atlas: { page: "ui/main-0", x: 583, y: 595, width: 256, height: 128 }
+ * };
+ * ```
+ */
+type ManifestFile = {
+  key: string;
+  path?: string;
+  kind?: AssetKind;
+  width: number;
+  height: number;
+  mb: number;
+  pages?: readonly FontPage[];
+  nine?: NineSlice;
+  atlas?: AtlasFrame;
+};
+/**
+ * One bundle of the manifest: which feature owns it, when it loads and what it costs. `pages` is
+ * written by the packer only, sorted by id; `mb` is then its pages, its loose textures, its font
+ * pages and its audio bytes together.
+ *
+ * @example
+ * ```ts
+ * const bundle: ManifestBundle = { feature: "ui", tier: "core", mb: 0.125, files: [] };
+ * ```
+ */
+type ManifestBundle = {
+  feature: string;
+  tier: Tier;
+  mb: number;
+  pages?: readonly AtlasPage[];
+  files: readonly ManifestFile[];
+};
+/**
+ * The manifest: the contract between the scanner, the packer, this plugin and the editor. Version
+ * `1` is the dev manifest of `bun run assets:keys`, version `2` the packed one of
+ * `bun run assets:pack`; the plugin reads both. Bundles are sorted by name, pages by id and files
+ * by key, so two runs on the same tree give the same bytes.
+ *
+ * @example
+ * ```ts
+ * // A dev build: loose files, straight from the features.
+ * const manifest: Manifest = {
+ *   version: 1,
+ *   bundles: { ui: { feature: "ui", tier: "core", mb: 0, files: [] } }
+ * };
+ *
+ * createApp({ plugins: [...screen], pluginConfigs: { assets: { manifest } } });
+ *
+ * // The packed manifest of the same game: the panel is cut out of the page "ui/main-0".
+ * const page = { id: "ui/main-0", path: "ui/main-0-3b1d55a0c9.webp", width: 966, height: 1365, mb: 5.03 };
+ * const atlas = { page: "ui/main-0", x: 583, y: 595, width: 256, height: 128 };
+ * const panel = { key: "ui.panel", width: 256, height: 128, mb: 0, atlas };
+ * const packed: Manifest = {
+ *   version: 2,
+ *   bundles: { ui: { feature: "ui", tier: "core", mb: 5.03, pages: [page], files: [panel] } }
+ * };
+ * ```
+ */
+type Manifest = {
+  version: 1 | 2;
+  bundles: Readonly<Record<string, ManifestBundle>>;
+};
+/**
+ * What a feature declares about one of its bundles. `files` are globs relative to the feature's
+ * `assets/`; a bundle with `files` takes those files out of the feature's default bundle.
+ *
+ * @example
+ * ```ts
+ * const spec: BundleSpec = { tier: "lazy", files: ["chains/*.png"] };
+ * ```
+ */
+type BundleSpec = {
+  tier: Tier;
+  files?: readonly string[];
+};
+/**
+ * What `defineBundles` returns: plain data the scanner and the plugin both read.
+ *
+ * @example
+ * ```ts
+ * const bundles: BundleMap = {
+ *   kind: "bundles",
+ *   map: { board: { tier: "scene" }, "board.chains": { tier: "lazy", files: ["chains/*.png"] } }
+ * };
+ * ```
+ */
+type BundleMap<Key extends string = string> = {
+  kind: "bundles";
+  map: Partial<Record<Key, BundleSpec>>;
+};
+/**
+ * `defineBundles` bound to the bundle keys of one game. `defineGame` returns it, so a key that is
+ * not in `BundleKey` does not compile.
+ *
+ * @example
+ * ```ts
+ * const defineGameBundles: DefineBundles<"board" | "board.chains"> = defineBundles;
+ * ```
+ */
+type DefineBundles<Key extends string> = (map: Partial<Record<Key, BundleSpec>>) => BundleMap<Key>;
+/**
+ * The `load` descriptor helper bound to the bundle keys of one game.
+ *
+ * @example
+ * ```ts
+ * const loadGameBundle: LoadBundles<"board" | "board.chains"> = load;
+ * ```
+ */
+type LoadBundles<Key extends string> = (bundle: Key | readonly Key[]) => Descriptor;
+/**
+ * What the `load` effect resolves with, so a loading node can write its own progress.
+ *
+ * @example
+ * ```ts
+ * const result: LoadResult = { loaded: ["board.chains"], mb: 1.25 };
+ * ```
+ */
+type LoadResult = {
+  loaded: string[];
+  mb: number;
+};
+/**
+ * Why a bundle was loaded. It is the reason of the caller that started the load; a later waiter
+ * changes nothing.
+ *
+ * @example
+ * ```ts
+ * const reason: LoadReason = "enter";
+ * ```
+ */
+type LoadReason = "boot" | "enter" | "request" | "preload";
+/**
+ * The running load of one bundle. Every caller is a waiter; the last one to leave aborts it.
+ * `promise` never rejects: what broke waits in `error`, so a load nobody joined any more cannot
+ * become an unhandled rejection.
+ */
+type Inflight = {
+  promise: Promise<void>;
+  controller: AbortController;
+  waiters: number;
+  error: unknown;
+};
+/**
+ * A loaded font: the `.fnt` file as text and the page textures it names. `text` installs the
+ * first page in the renderer; every page is destroyed with the bundle.
+ *
+ * @example
+ * ```ts
+ * const font: FontAsset = { fnt: 'info face="body" size=32', texture };
+ * ```
+ */
+type FontAsset = {
+  fnt: string;
+  texture: Texture;
+};
+/**
+ * What the plugin keeps for a loaded font: the public pair plus every page, because a font of
+ * two pages owns two textures.
+ */
+type LoadedFont = FontAsset & {
+  pages: readonly Texture[];
+};
+/**
+ * What one bundle brought: textures by asset key (a packed file's is a slice of its page), fonts
+ * with their pages, the undecoded bytes of the audio files, and the atlas pages by page id. A
+ * running load fills the same four maps before they are published.
+ */
+type LoadedAssets = {
+  textures: Map<string, Texture>;
+  fonts: Map<string, LoadedFont>;
+  audio: Map<string, ArrayBuffer>;
+  pages: Map<string, Texture>;
+};
+/**
+ * What the plugin knows about one bundle. `lastUsed` is the value of `useCounter` at the last
+ * touch: a counter, never a clock.
+ */
+type BundleRecord = LoadedAssets & {
+  status: "idle" | "loading" | "loaded";
+  inflight: Inflight | undefined;
+  lastUsed: number;
+};
+/**
+ * The background preload. A new rest node replaces it and aborts the old controller.
+ */
+type PreloadQueue = {
+  bundles: string[];
+  controller: AbortController;
+};
+/**
+ * assets plugin config.
+ *
+ * @example
+ * ```ts
+ * createApp({
+ *   plugins: [...screen, boardFeature],
+ *   pluginConfigs: { assets: { manifest: "/assets/manifest.json", textureBudgetMb: 192 } }
+ * });
+ * ```
+ */
+type Config = {
+  /** URL of `manifest.json`, or the parsed manifest itself (tests, headless). `undefined`: an empty manifest. */manifest: string | Manifest | undefined; /** Texture memory budget in MB. */
+  textureBudgetMb: number; /** How many edges from a rest node the background preload looks ahead. `0` turns preload off. */
+  preloadDepth: number; /** Prefix of every file URL. The CDN seam. `undefined`: the folder of the manifest URL, or `"/"`. */
+  baseUrl: string | undefined; /** I/O seam. `undefined`: the browser pair plus `renderer.sync.textures`, or headless. */
+  io: AssetsIo | undefined;
+};
+/**
+ * assets plugin state.
+ */
+type State = {
+  /** `undefined` means headless: manifest only, no fetches, no textures. */io: AssetsIo | undefined; /** Empty until `onStart` read it. */
+  manifest: Manifest; /** Asset key to the bundle that carries it. */
+  bundleOfKey: Map<string, string>; /** Scene id to its bundle, read from the `scenes` key of `flow.features`. */
+  bundleOfScene: Map<string, string>; /** Flow id to the feature that owns it, read from the `flows` key of `flow.features`. */
+  featureOfFlow: Map<string, string>;
+  records: Map<string, BundleRecord>; /** Bundles of the node entered last. They are never unloaded. */
+  pinned: Set<string>; /** The bundle of the scene entered last. A node without `scene` keeps it. */
+  sceneBundle: string | undefined;
+  queue: PreloadQueue | undefined;
+  current: NodeInfo | undefined;
+  useCounter: number; /** Keys already reported missing, so one key warns and starts its background load once. */
+  warned: Set<string>; /** `onEnter`, the `load` handler and the texture provider. */
+  removers: Array<() => void>;
+};
+/**
+ * What `usage()` reports about one loaded bundle.
+ *
+ * @example
+ * ```ts
+ * const entry: BundleUsage = { name: "board", tier: "scene", mb: 3.5, lastUsed: 12 };
+ * ```
+ */
+type BundleUsage = {
+  name: string;
+  tier: Tier;
+  mb: number;
+  lastUsed: number;
+};
+/**
+ * What `usage()` reports: the numbers a dev overlay and the tests read.
+ *
+ * @example
+ * ```ts
+ * const report: Usage = { textureMb: 3.5, budgetMb: 192, bundles: [] };
+ * ```
+ */
+type Usage = {
+  textureMb: number;
+  budgetMb: number;
+  bundles: readonly BundleUsage[];
+};
+/**
+ * assets plugin events.
+ *
+ * @example
+ * ```ts
+ * // A game reports every loaded bundle to its analytics.
+ * createPlugin("loadReport", {
+ *   depends: [assetsPlugin],
+ *   hooks: ctx => ({ "assets:bundle-loaded": ({ bundle, mb }) => ctx.log.info("loaded", { bundle, mb }) })
+ * }); // the board bundle logs { bundle: "board", mb: 3.5 }
+ *
+ * // A splash screen fills its loading bar file by file.
+ * createPlugin("loadingBar", {
+ *   depends: [assetsPlugin],
+ *   createState: () => ({ share: 0 }),
+ *   hooks: ctx => ({
+ *     "assets:bundle-progress": ({ loaded, total }) => {
+ *       ctx.state.share = loaded / total;
+ *     }
+ *   })
+ * }); // a board bundle of four files sets share to 0.25, 0.5, 0.75 and 1; bundle-loaded follows
+ * ```
+ */
+type Events = {
+  /** Every file of a bundle is a texture now. */"assets:bundle-loaded": {
+    bundle: string;
+    tier: Tier;
+    mb: number;
+    reason: LoadReason;
+  };
+  /**
+   * One more file of a running load settled. `loaded` counts the settled files (a font once, with
+   * its pages), `total` is the file count of the bundle; the last one of a load has
+   * `loaded === total` and comes before `assets:bundle-loaded`. An aborted load sends none.
+   */
+  "assets:bundle-progress": {
+    bundle: string;
+    loaded: number;
+    total: number;
+  }; /** The textures of a bundle were destroyed. `keys` names every asset that went with it. */
+  "assets:bundle-unloaded": {
+    bundle: string;
+    tier: Tier;
+    mb: number;
+    reason: "budget" | "request";
+    keys: readonly string[];
+  };
+};
+/**
+ * assets plugin API, `app.assets`. Bundles of textures by key: the graph decides when they arrive,
+ * the budget decides when they leave.
+ *
+ * @example
+ * ```ts
+ * // A loading node asks for a bundle and a game system asks for one texture of it.
+ * await app.assets.load("board");
+ * app.assets.texture("board.cell"); // the Pixi texture, once the bundle is there
+ * ```
+ */
+type Api = {
+  /**
+   * Loads every file of a bundle. An already loaded bundle resolves at once, a loading one joins
+   * the running load. Headless it resolves at once and touches nothing.
+   *
+   * @param bundle - Name of a bundle of the manifest.
+   * @returns A promise that resolves when every texture of the bundle exists.
+   * @throws {Error} When the manifest has no such bundle, and when a file fails to load.
+   * @example
+   * ```ts
+   * // A game plugin warms the bundle of a timed event before its popup can open.
+   * await app.assets.load("event.halloween");
+   * app.assets.isLoaded("event.halloween"); // true
+   * ```
+   */
+  load(bundle: string): Promise<void>;
+  /**
+   * Destroys the textures of a bundle and tells `renderer` that its keys are gone. A pinned
+   * bundle and the tiers `boot` and `core` are refused with a warning. A running load is aborted.
+   *
+   * @param bundle - Name of a loaded bundle.
+   * @example
+   * ```ts
+   * // The timed event ended: its textures go back to the GPU.
+   * app.assets.unload("event.halloween");
+   * app.assets.isLoaded("event.halloween"); // false
+   * ```
+   */
+  unload(bundle: string): void;
+  /**
+   * Tells whether every texture of a bundle exists. Headless every bundle of the manifest counts
+   * as loaded, so a headless game never waits for a loading screen.
+   *
+   * @param bundle - Name of a bundle of the manifest.
+   * @returns True when the bundle is loaded.
+   * @example
+   * ```ts
+   * // `scenes` skips its loading path when the bundle of the next scene is already there.
+   * if (!app.assets.isLoaded("board")) await app.assets.load("board");
+   * ```
+   */
+  isLoaded(bundle: string): boolean;
+  /**
+   * The texture of a loaded asset key. It touches the use counter of the bundle, which is what
+   * the LRU reads. A key of a bundle that is not loaded warns once, starts a background load and
+   * answers `undefined`; the sprites waiting for it are textured when that load lands. A key packed
+   * in an atlas answers its slice of the page, so a game never sees the difference.
+   *
+   * @param key - Asset key, as `generated/assets.ts` types it.
+   * @returns The texture, or `undefined` while the bundle is not loaded.
+   * @example
+   * ```ts
+   * // A game system builds one Pixi object by hand instead of using the Sprite component.
+   * const texture = app.assets.texture("board.cell"); // undefined until the board bundle lands
+   * ```
+   */
+  texture(key: string): Texture | undefined;
+  /**
+   * The font of a loaded asset key: the `.fnt` file as text and the texture of its first page.
+   * It touches the use counter of the bundle. A font of a bundle that is not loaded, a key of
+   * another kind and every headless run answer `undefined`.
+   *
+   * @param key - Asset key of a `.fnt` file, as `generated/assets.ts` types it in `FontKey`.
+   * @returns The font, or `undefined` while its bundle is not loaded.
+   * @example
+   * ```ts
+   * // `text` installs the font in the renderer when the bundle that carries it arrived.
+   * const font = app.assets.font("ui.body"); // { fnt: 'info face="body" size=32', texture }
+   *
+   * if (font !== undefined) app.renderer.sync.fonts.install("ui.body", font.fnt, font.texture);
+   * ```
+   */
+  font(key: string): FontAsset | undefined;
+  /**
+   * The bytes of a loaded audio file, exactly as they were fetched: this plugin never decodes
+   * them. It touches the use counter of the bundle. A bundle that is not loaded, a key of
+   * another kind and every headless run answer `undefined`.
+   *
+   * @param key - Asset key of an `.mp3` file, as `generated/assets.ts` types it in `AudioKey`.
+   * @returns The undecoded bytes, or `undefined` while its bundle is not loaded.
+   * @example
+   * ```ts
+   * // `audio` decodes a sound once and keeps it until the bundle is unloaded.
+   * const bytes = app.assets.audio("ui.click"); // the ArrayBuffer of click.mp3
+   * const buffer = bytes === undefined ? undefined : await context.decodeAudioData(bytes);
+   * ```
+   */
+  audio(key: string): ArrayBuffer | undefined;
+  /**
+   * What the loaded bundles cost, sorted by name. `lastUsed` is the use counter, not a clock.
+   *
+   * @returns The used and allowed megabytes and one entry per loaded bundle.
+   * @example
+   * ```ts
+   * // A dev overlay draws the memory bar of the game.
+   * const { textureMb, budgetMb, bundles } = app.assets.usage();
+   * // textureMb: 3.5, budgetMb: 192, bundles: [{ name: "board", tier: "scene", mb: 3.5, lastUsed: 12 }]
+   * ```
+   */
+  usage(): Usage;
+};
+/**
+ * Resolved dependency APIs.
+ */
+type Deps = {
+  flow: Api$1;
+  renderer: Api$2;
+  time: Api$3;
+};
+/**
+ * What the kernel context offers before the deps are attached.
+ *
+ * `index.ts` writes `events` with an annotated `register` (core spec `14-EVENT-REGISTRATION.md`
+ * row 8), so the two own events reach the context the kernel hands the factories and `emit` is the
+ * kernel's own, assets-typed one. No member of the context is cast.
+ */
+type KernelSlice = PluginCtx<Config, State, Events> & {
+  readonly global: object;
+  readonly log: Log.LogApi;
+  readonly require: Require;
+};
+/**
+ * Domain context shared by the files of the plugin.
+ */
+type AssetsCtx = KernelSlice & {
+  readonly deps: Deps;
+};
+/**
+ * Payload of the one event assets listens to.
+ */
+type FlowRest = {
+  path: string;
+  checkpoint: boolean;
+};
+//#endregion
+export { DefineBundles as a, LoadReason as c, Tier as d, Usage as f, Config as i, Manifest as l, BundleMap as n, Events as o, types_d_exports as p, BundleSpec as r, LoadBundles as s, Api as t, State as u };