@jgengine/assets 0.11.0 → 0.12.0

package/CHANGELOG.md

@@ -12,6 +12,32 @@ Agents building on the published SDK can also read this programmatically:
 same data as typed values, so an updater can diff its installed version against
 the latest and surface the migration steps.
 
+## 0.12.0
+
+### Migrate
+
+- **Author games through `defineGame` from `@jgengine/shell`** — it is the single public authoring entry (and carries the define-game capability tag). Core's constructor was renamed `defineGame` → `defineGameDefinition` (`@jgengine/core/game/defineGame`); only hosts and tooling call it. If you imported `defineGame` from core, switch the import to `@jgengine/shell`. `GamePlayer`/`GamePlayerShell` are `@internal` now — `GameHost` is the documented mount, and it owns the editor summon (`?mode=editor`, F2+E, dev save endpoint), so delete any per-game editor bootstrap.
+- **Declare your world with `world()`** (`@jgengine/core/world/place`): `world({ id, ground: { mode, size, surface? }, physics? })` with `flat` / `round` / `voxel` / `board` ground. New scaffolds emit a thin infinite flat place instead of the old 96 m meadow. `environment()` still works but is demoted to the legacy consumption path for editor-written scene data — **nothing required** for existing games; new worlds should use `world()` and author all dressing in the editor.
+- Everything else is additive — stat pools, minimap marker sources, auction house, city/path generation, editor workspaces require no changes to existing games.
+
+### Added
+
+- **World = place: `world()` API** (#1178) — a world is substrate + laws, not a coded diorama. `@jgengine/core/world/place` ships `world({ id, ground: { mode, size, surface?, generator? }, physics? })`; size is discriminated by mode (flat `{x,z}` with `Infinity` axes, round `{radius}`, voxel generator domain, board `{x,y}` cells — TS and runtime both reject mismatches). `ground.surface` carries matter/feel laws (metal vs slime vs felt) read by the same rule systems; per-place `physics` resolves over the game default; multiple worlds per game are first-class. The shell renders place substrates (`PlaceScene`) under the engine default sky; seeds derive from world id + save via `seedForPlace`.
+- **`@jgengine/shell/gameKit`** — happy-path authoring surface: authoring, mount, stores, systems, authored-scene helpers, HUD primitives, seeded rng in one import.
+- **Portable generic stat pools** — `@jgengine/core/stats/statPool`: bounded named pools (health, energy, heat, ammo…) with the entity-stats integration rebuilt on them; recipe in skill `jgengine-combat`.
+- **Auction-house economy primitives** (#1086) — `@jgengine/core/economy/auctionBook` (timed bid auctions, escrowed bids, outbid refunds, optional buyout, anti-snipe close extension, seller settlement minus house cut) plus market price history.
+- **Portable minimap marker sources** — core world seam feeding game minimaps; recipe in skill `jgengine-ui`.
+- **Unified seed-driven path network + city generation v2** (#1103, #1106) — streets/blocks/buildings with grid-ness, curviness, branching and block-size dials; zone bands, weighted building-class mixes, massing pieces, balance presets, junction-centered clustering, road-derived block polygons and parcels. Shell renders realistic roads: real intersections, curbs, lane lines, tunnels, and roads riding bridge decks.
+- **Physical fidelity** — mesh-accurate hitboxes (shots pass through holes in concave models, #1075), auto-fit entity/object colliders from measured model bounds (#1072), movement obstruction reading fitted boxes + compound-box openings (#1077).
+- **Editor overhaul** (#1110) — materials / lighting / scripting / animation-timeline / multiplayer workspaces, command palette, minimap bake wired end-to-end (#1036), real offscreen GLB thumbnails in the content browser, hierarchy drag-drop + keyboard + context menus + per-object visibility/lock, multi-select inspector, console RPC, asset drag-place, ortho projection, pivot modes, play chrome.
+- **Editor authoring pipeline** — author entity definitions and starter catalogs (#1012), author catalogs/schema fields in the Data tab (#1043), promote an authored scene folder into a runnable game (#1011), authored triggers promoted to a shared primitive with goal/win rules (#1013), asset import rewrites the game's `game/assets.ts` (#1042).
+- **Skills** — research-backed `game-design` and `level-design` skills (#962); every-game-owns-custom-UI invariant codified (#1148).
+
+### Changed
+
+- `npx jgengine create` scaffolds a thin infinite flat `world()` place; the editor `blankWorld` no longer pre-bakes seeded grass. Dressing belongs in `editor.scene.json`.
+- Environment studio visual-quality pass — turf tufts, depth-aware water, relief soil, weathered poles; grass fields no longer rebuild geometry per frame (#1090).
+
 ## 0.11.0
 
 ### Migrate

package/README.md

@@ -75,7 +75,7 @@ Run in-repo with `bun run --cwd packages/assets src/cli/pull.ts <verb> GǪ`. (`a
 
 1. **Mirror base override** G�� `--mirror <baseUrl>` (or the `JGENGINE_ASSETS_MIRROR` env var if `--mirror` is not passed) G�� the archive is expected at `<baseUrl>/<provider>/<source-id>.zip`, e.g. `https://my-mirror.example.com/quaternius/quaternius-stylized-nature.zip`.
 2. **The default GitHub-release mirror** G�� `https://github.com/Noisemaker111/jgengine/releases/download/packs/<provider>-<source-id>.zip`, on this repo's own rolling `packs` release (no separate assets repo). github.com is reachable from every cloud sandbox with no network-policy change, so zero-setup sessions still pull. `.github/workflows/mirror-assets.yml` (weekly cron + manual dispatch) keeps the release in sync with `src/sources/*.ts` automatically G�� adding a catalog entry is the whole publishing step, no manual upload. Skip this hop with `JGENGINE_ASSETS_NO_DEFAULT_MIRROR=1`. Model/sprite pack failures fail the job; individual ambientCG material 404s are soft (logged, non-fatal).
-3. **The primary provider path** G�� pinned `{ url, sha256? }` when stable: **KayKit** G�� `github.com/KayKit-Game-Assets/*/archive/GǪ/main.zip`; **Quaternius** free Standard packs G�� OpenGameArt direct zips (site pages JS-gate). Else scrape. `extractGlbs` packs co-located `.gltf`+`.bin` into `.glb`.
+3. **The primary provider path** G�� pinned `{ url, sha256? }` when stable: **KayKit** G�� `github.com/KayKit-Game-Assets/*/archive/GǪ/main.zip`; **Quaternius** free Standard packs G�� OpenGameArt direct zips (site pages JS-gate). Else scrape. `extractGlbs` packs co-located `.gltf`+`.bin` into `.glb`, flattens external image URIs to basenames, and returns each referenced texture so `pull` writes it beside the models — a pulled pack renders textured out of the box.
 4. **The pack's own `mirror`** G�� an optional direct archive URL set on the `AssetSource` entry itself (`src/sources/*.ts`), tried as a last resort.
 
 If every attempt fails, `pull` throws one aggregated error naming every URL it tried and why each one failed. Whenever the source's `download` is pinned with a `sha256`, the downloaded bytes are hashed and checked against it **no matter which path supplied them** G�� a mirror serving stale or tampered bytes is rejected and the next source in the chain is tried instead.

package/dist/catalogs/build.d.ts

@@ -1,5 +1,20 @@
 import { type AssetCatalog } from "@jgengine/core/scene/assetCatalog";
 import type { IndexEntry } from "../manifest.js";
+/**
+ * A durable, hand-or-tool authored catalog entry that is not part of the generated pack index,
+ * singles, or aliases — the shape the editor writes into a promoted game's `src/game/assets.ts`
+ * when an asset is imported. `label` is human-facing only and is intentionally not registered
+ * into the catalog (it mirrors how a single asset's author/license live only in the source
+ * literal), so at runtime an extra resolves to exactly `{ url }`.
+ */
+export interface CatalogExtra {
+    /** Catalog id the entry resolves under (matches what a folder rescan would produce). */
+    id: string;
+    /** URL the shipped game serves the model from (e.g. `/models/imported/Ship.glb`). */
+    url: string;
+    /** Human-facing label kept only in the source literal; never registered into the catalog. */
+    label?: string;
+}
 export interface BuildCatalogOptions {
     /** URL prefix where pulled pack GLBs live (consumer's `public/models`). */
     basePath?: string;
@@ -7,6 +22,18 @@ export interface BuildCatalogOptions {
     sources?: readonly string[];
     includeAliases?: boolean;
     includeSingles?: boolean;
+    /**
+     * Extra catalog entries registered after packs/singles and before aliases: imported assets the
+     * editor persists into a promoted game's typed catalog. Registered last-writer-wins after packs
+     * (so an extra can override a pack id) but before aliases (so an alias can target an extra).
+     */
+    extras?: readonly CatalogExtra[];
 }
 export declare function entryUrl(basePath: string, entry: IndexEntry): string;
+/**
+ * Builds a game's asset catalog from the generated CC0 pack index plus singles, extras, and aliases.
+ * Registration order is packs → singles → {@link BuildCatalogOptions.extras | extras} → aliases:
+ * packs and singles come first, extras override them last-writer-wins, and aliases resolve last so
+ * they can target an extra. See {@link BuildCatalogOptions} for filtering and opt-outs.
+ */
 export declare function buildCatalog(options?: BuildCatalogOptions): AssetCatalog;

package/dist/catalogs/build.js

@@ -6,6 +6,12 @@ import { sources as declaredSources } from "../sources/index.js";
 export function entryUrl(basePath, entry) {
     return `${basePath.replace(/\/+$/, "")}/${entry.source}/${entry.file}`;
 }
+/**
+ * Builds a game's asset catalog from the generated CC0 pack index plus singles, extras, and aliases.
+ * Registration order is packs → singles → {@link BuildCatalogOptions.extras | extras} → aliases:
+ * packs and singles come first, extras override them last-writer-wins, and aliases resolve last so
+ * they can target an extra. See {@link BuildCatalogOptions} for filtering and opt-outs.
+ */
 export function buildCatalog(options = {}) {
     const basePath = options.basePath ?? "/models";
     const includeAliases = options.includeAliases ?? true;
@@ -24,19 +30,30 @@ export function buildCatalog(options = {}) {
         if (sourceFilter !== null && !sourceFilter.has(entry.source))
             continue;
         const url = entryUrl(basePath, entry);
-        catalog.register(entry.id, entry.dims === undefined ? { url } : { url, dims: entry.dims });
+        catalog.register(entry.id, {
+            url,
+            ...(entry.dims === undefined ? {} : { dims: entry.dims }),
+            ...(entry.collisionMesh === undefined ? {} : { collisionMesh: entry.collisionMesh }),
+        });
     }
     if (includeSingles) {
         for (const single of singles) {
             catalog.register(single.id, { url: single.url });
         }
     }
+    for (const extra of options.extras ?? []) {
+        catalog.register(extra.id, { url: extra.url });
+    }
     if (includeAliases) {
         for (const alias of aliases) {
             const ref = catalog.resolve(alias.target);
             if (ref === null)
                 continue;
-            catalog.register(alias.key, ref.dims === undefined ? { url: ref.url } : { url: ref.url, dims: ref.dims });
+            catalog.register(alias.key, {
+                url: ref.url,
+                ...(ref.dims === undefined ? {} : { dims: ref.dims }),
+                ...(ref.collisionMesh === undefined ? {} : { collisionMesh: ref.collisionMesh }),
+            });
         }
     }
     return catalog;

package/dist/cli/pull.js

@@ -3,7 +3,7 @@ import { execFileSync } from "node:child_process";
 import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { downloadPackArchive, extractGlbs, extractSpriteFiles, extractTextures } from "../download.js";
+import { downloadPackArchive, extractGlbs, extractSpriteFiles } from "../download.js";
 import { rankAssets } from "../find.js";
 import { generatedIndex } from "../generated/index.js";
 import { generatedSpriteIndex } from "../generated-sprites/index.js";
@@ -196,19 +196,15 @@ async function fetchPackInto(source, outRoot, options) {
             writeFileSync(join(outDir, file.file), file.bytes);
         return { outDir, models: files.length, textures: 0, url };
     }
-    const glbs = extractGlbs(archive);
-    if (glbs.length === 0)
+    const { models, images } = extractGlbs(archive);
+    if (models.length === 0)
         fail(`no .glb files found in ${source.id} archive`);
     mkdirSync(outDir, { recursive: true });
-    for (const glb of glbs)
+    for (const glb of models)
         writeFileSync(join(outDir, glb.file), glb.bytes);
-    const textures = extractTextures(archive);
-    for (const texture of textures) {
-        const dest = join(outDir, texture.file);
-        mkdirSync(dirname(dest), { recursive: true });
-        writeFileSync(dest, texture.bytes);
-    }
-    return { outDir, models: glbs.length, textures: textures.length, url };
+    for (const image of images)
+        writeFileSync(join(outDir, image.file), image.bytes);
+    return { outDir, models: models.length, textures: images.length, url };
 }
 function readSingles() {
     if (!existsSync(singlesJson))

package/dist/collisionMeshAssets.d.ts

@@ -0,0 +1,2 @@
+/** Catalog assets that ship a collision mesh in the generated index. Opt-in only: each entry adds ~10-30KB of quantized triangles to the index and a BVH raycast per query, so list only concave models whose fitted box lies (archways, rings, frames). */
+export declare const COLLISION_MESH_ASSET_IDS: ReadonlySet<string>;

package/dist/collisionMeshAssets.js

@@ -0,0 +1,6 @@
+/** Catalog assets that ship a collision mesh in the generated index. Opt-in only: each entry adds ~10-30KB of quantized triangles to the index and a BVH raycast per query, so list only concave models whose fitted box lies (archways, rings, frames). */
+export const COLLISION_MESH_ASSET_IDS = new Set([
+    "kaykit-dungeon/wall_arched",
+    "kaykit-dungeon/wall_archedwindow_open",
+    "kaykit-dungeon/wall_archedwindow_gated",
+]);

package/dist/dims.d.ts

@@ -1,3 +1,10 @@
 import type { ModelDims } from "@jgengine/core/scene/assetCatalog";
+import { type CollisionMeshData } from "@jgengine/core/scene/collisionMesh";
 export type { ModelDims };
 export declare function readGlbDims(bytes: Uint8Array): ModelDims | null;
+/**
+ * Extract a model-space collision triangle soup from a GLB and compress it with {@link encodeCollisionMesh}.
+ * Walks the default scene, transforming each TRIANGLES primitive's float32 VEC3 positions by the node's world
+ * matrix, and returns `null` for a JSON-only GLB or when no triangle survives quantization.
+ */
+export declare function readGlbCollisionMesh(bytes: Uint8Array): CollisionMeshData | null;

package/dist/dims.js

@@ -1,6 +1,8 @@
+import { encodeCollisionMesh } from "@jgengine/core/scene/collisionMesh";
 const IDENTITY = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
 const GLB_MAGIC = 0x46546c67;
 const CHUNK_JSON = 0x4e4f534a;
+const CHUNK_BIN = 0x004e4942;
 function multiply(a, b) {
     const out = new Array(16);
     for (let col = 0; col < 4; col += 1) {
@@ -139,5 +141,157 @@ export function readGlbDims(bytes) {
         footprint: { w: bounds.max[0] - bounds.min[0], d: bounds.max[2] - bounds.min[2] },
         center: { x: (bounds.min[0] + bounds.max[0]) / 2, z: (bounds.min[2] + bounds.max[2]) / 2 },
         minY: bounds.min[1],
+        maxY: bounds.max[1],
     };
 }
+const COMPONENT_FLOAT = 5126;
+const COMPONENT_U8 = 5121;
+const COMPONENT_U16 = 5123;
+const COMPONENT_U32 = 5125;
+const MODE_TRIANGLES = 4;
+/** The GLB's binary chunk, or `null` for a JSON-only GLB (no geometry buffer to read). */
+function readBinChunk(bytes) {
+    if (bytes.byteLength < 20)
+        return null;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (view.getUint32(0, true) !== GLB_MAGIC)
+        return null;
+    const jsonChunkLength = view.getUint32(12, true);
+    if (view.getUint32(16, true) !== CHUNK_JSON)
+        return null;
+    const header = 20 + jsonChunkLength;
+    if (header + 8 > bytes.byteLength)
+        return null;
+    const chunkLength = view.getUint32(header, true);
+    if (view.getUint32(header + 4, true) !== CHUNK_BIN)
+        return null;
+    const start = header + 8;
+    const end = Math.min(start + chunkLength, bytes.byteLength);
+    return bytes.subarray(start, end);
+}
+/** Float32 VEC3 accessor values in model space, honoring bufferView/accessor byteOffset and byteStride; `null` for a malformed or out-of-bounds accessor. */
+function readVec3Accessor(gltf, bin, accessorIndex) {
+    const accessor = gltf.accessors?.[accessorIndex];
+    if (accessor === undefined)
+        return null;
+    if (accessor.componentType !== COMPONENT_FLOAT || accessor.type !== "VEC3")
+        return null;
+    const count = accessor.count;
+    if (count === undefined || count <= 0)
+        return null;
+    if (accessor.bufferView === undefined)
+        return null;
+    const bufferView = gltf.bufferViews?.[accessor.bufferView];
+    if (bufferView === undefined)
+        return null;
+    const stride = bufferView.byteStride ?? 12;
+    const base = (bufferView.byteOffset ?? 0) + (accessor.byteOffset ?? 0);
+    if (base < 0 || base + (count - 1) * stride + 12 > bin.byteLength)
+        return null;
+    const view = new DataView(bin.buffer, bin.byteOffset, bin.byteLength);
+    const out = new Float64Array(count * 3);
+    for (let i = 0; i < count; i += 1) {
+        const offset = base + i * stride;
+        out[i * 3] = view.getFloat32(offset, true);
+        out[i * 3 + 1] = view.getFloat32(offset + 4, true);
+        out[i * 3 + 2] = view.getFloat32(offset + 8, true);
+    }
+    return out;
+}
+/** Scalar index accessor values (u8/u16/u32), honoring byteOffset and byteStride; `null` for a malformed or out-of-bounds accessor. */
+function readIndexAccessor(gltf, bin, accessorIndex) {
+    const accessor = gltf.accessors?.[accessorIndex];
+    if (accessor === undefined || accessor.type !== "SCALAR")
+        return null;
+    const componentType = accessor.componentType;
+    const componentBytes = componentType === COMPONENT_U8 ? 1 : componentType === COMPONENT_U16 ? 2 : componentType === COMPONENT_U32 ? 4 : 0;
+    if (componentBytes === 0)
+        return null;
+    const count = accessor.count;
+    if (count === undefined || count <= 0)
+        return null;
+    if (accessor.bufferView === undefined)
+        return null;
+    const bufferView = gltf.bufferViews?.[accessor.bufferView];
+    if (bufferView === undefined)
+        return null;
+    const stride = bufferView.byteStride ?? componentBytes;
+    const base = (bufferView.byteOffset ?? 0) + (accessor.byteOffset ?? 0);
+    if (base < 0 || base + (count - 1) * stride + componentBytes > bin.byteLength)
+        return null;
+    const view = new DataView(bin.buffer, bin.byteOffset, bin.byteLength);
+    const out = new Uint32Array(count);
+    for (let i = 0; i < count; i += 1) {
+        const offset = base + i * stride;
+        out[i] =
+            componentType === COMPONENT_U8
+                ? view.getUint8(offset)
+                : componentType === COMPONENT_U16
+                    ? view.getUint16(offset, true)
+                    : view.getUint32(offset, true);
+    }
+    return out;
+}
+/** Append one triangle primitive's world-space geometry to the soup; skips non-triangle modes and malformed accessors, appending nothing on failure. */
+function addPrimitive(gltf, bin, primitive, world, soup) {
+    if ((primitive.mode ?? MODE_TRIANGLES) !== MODE_TRIANGLES)
+        return;
+    const accessorIndex = primitive.attributes?.POSITION;
+    if (accessorIndex === undefined)
+        return;
+    const positions = readVec3Accessor(gltf, bin, accessorIndex);
+    if (positions === null)
+        return;
+    let localIndices = null;
+    if (primitive.indices !== undefined) {
+        localIndices = readIndexAccessor(gltf, bin, primitive.indices);
+        if (localIndices === null)
+            return;
+    }
+    const vertexBase = soup.positions.length / 3;
+    const vertexCount = positions.length / 3;
+    for (let v = 0; v < vertexCount; v += 1) {
+        const [wx, wy, wz] = transformPoint(world, positions[v * 3], positions[v * 3 + 1], positions[v * 3 + 2]);
+        soup.positions.push(wx, wy, wz);
+    }
+    if (localIndices === null) {
+        for (let v = 0; v < vertexCount; v += 1)
+            soup.indices.push(vertexBase + v);
+    }
+    else {
+        for (let i = 0; i < localIndices.length; i += 1)
+            soup.indices.push(vertexBase + localIndices[i]);
+    }
+}
+function walkCollision(gltf, bin, nodeIndex, parent, soup) {
+    const node = gltf.nodes?.[nodeIndex];
+    if (node === undefined)
+        return;
+    const world = multiply(parent, fromTRS(node));
+    if (node.mesh !== undefined) {
+        const mesh = gltf.meshes?.[node.mesh];
+        for (const primitive of mesh?.primitives ?? [])
+            addPrimitive(gltf, bin, primitive, world, soup);
+    }
+    for (const child of node.children ?? [])
+        walkCollision(gltf, bin, child, world, soup);
+}
+/**
+ * Extract a model-space collision triangle soup from a GLB and compress it with {@link encodeCollisionMesh}.
+ * Walks the default scene, transforming each TRIANGLES primitive's float32 VEC3 positions by the node's world
+ * matrix, and returns `null` for a JSON-only GLB or when no triangle survives quantization.
+ */
+export function readGlbCollisionMesh(bytes) {
+    const gltf = readJsonChunk(bytes);
+    if (gltf === null)
+        return null;
+    const bin = readBinChunk(bytes);
+    if (bin === null)
+        return null;
+    const sceneIndex = gltf.scene ?? 0;
+    const roots = gltf.scenes?.[sceneIndex]?.nodes ?? gltf.nodes?.map((_, index) => index) ?? [];
+    const soup = { positions: [], indices: [] };
+    for (const root of roots)
+        walkCollision(gltf, bin, root, IDENTITY, soup);
+    return encodeCollisionMesh(soup);
+}

package/dist/download.d.ts

@@ -15,8 +15,9 @@ export interface ExtractedGlb {
     file: string;
     bytes: Uint8Array;
 }
-export interface ExtractedTexture {
-    /** Path relative to the pack output dir, e.g. "Textures/colormap.png". */
+/** An image a pack's models reference, shipped flat beside the `.glb` files. */
+export interface ExtractedPackImage {
+    /** Flat basename, e.g. "citybits_texture.png" — models reference it relative to their own URL. */
     file: string;
     bytes: Uint8Array;
 }
@@ -72,21 +73,38 @@ export interface DownloadPackResult {
   * @internal
   */
 export declare function downloadPackArchive(source: AssetSource, options?: DownloadPackOptions): Promise<DownloadPackResult>;
+/**
+ * External image basenames a packed `.glb` still references (its textures must
+ * sit beside it in the pack dir). Empty for self-contained models.
+ * @internal
+ */
+export declare function externalGlbImages(bytes: Uint8Array): string[];
 /**
  * Pack a `.gltf` + optional external `.bin` into a single `.glb` so reindex /
  * the shell only ever deal in one-file models. Strips buffer `uri` fields so
- * the binary chunk is self-contained. External image URIs stay as-is (loaders
- * resolve relative to the catalog URL only for GLB-embedded images).
+ * the binary chunk is self-contained; external image URIs are flattened to
+ * basenames so the pack ships each referenced texture beside the models
+ * (loaders resolve the relative URI against the model's own URL).
  * @internal
  */
 export declare function packGltfToGlb(gltfBytes: Uint8Array, binBytes?: Uint8Array): Uint8Array;
+/** What `extractGlbs` pulls out of a pack archive: the models plus the textures they reference. */
+export interface ExtractedPack {
+    models: ExtractedGlb[];
+    /** Every archive image some extracted model references, flattened to basenames. */
+    images: ExtractedPackImage[];
+}
 /**
- * Pull every GLB out of an archive. Also converts co-located `.gltf` + `.bin`
- * pairs (Quaternius Standard packs on OpenGameArt) into `.glb` so the catalog
- * stays one-file-per-model. GLB wins when both formats share a basename.
+ * Pull every GLB out of an archive, plus the textures those models reference.
+ * Converts co-located `.gltf` + `.bin` pairs (Quaternius Standard packs on
+ * OpenGameArt, KayKit bits packs) into `.glb` so the catalog stays
+ * one-file-per-model; GLB wins when both formats share a basename. External
+ * image URIs are flattened to basenames and the matching archive images are
+ * returned for writing beside the models — a pulled pack renders textured, not
+ * as white clay (#1005).
   * @internal
   */
-export declare function extractGlbs(archive: Uint8Array): ExtractedGlb[];
+export declare function extractGlbs(archive: Uint8Array): ExtractedPack;
 /** One SVG/PNG file pulled out of a sprite/icon-pack archive by `extractSpriteFiles`. */
 export interface ExtractedSpriteFile {
     file: string;
@@ -97,6 +115,4 @@ export interface ExtractedSpriteFile {
  */
 export declare function extractSpriteFiles(archive: Uint8Array): ExtractedSpriteFile[];
 /** @internal */
-export declare function extractTextures(archive: Uint8Array): ExtractedTexture[];
-/** @internal */
 export declare function sha256Hex(bytes: Uint8Array): Promise<string>;