@aethervtt/shard-procgen 0.0.1

package/dist/mesh-builder.js

@@ -0,0 +1,421 @@
+import { ShardError } from "@aethervtt/shard-core";
+import {
+  box,
+  capsule,
+  cone,
+  cube,
+  cylinder,
+  plane,
+  sphere,
+  torus
+} from "@aethervtt/shard-mesh";
+function icosphere(detail) {
+  if (!Number.isInteger(detail) || detail < 0 || detail > 8) {
+    throw new ShardError("procgen/bad-mesh", `icosphere detail must be 0 to 8, got ${detail}`, {
+      hint: "Detail 6 is already 40 962 vertices."
+    });
+  }
+  const phi = (1 + Math.sqrt(5)) / 2;
+  const base = [
+    -1,
+    phi,
+    0,
+    1,
+    phi,
+    0,
+    -1,
+    -phi,
+    0,
+    1,
+    -phi,
+    0,
+    0,
+    -1,
+    phi,
+    0,
+    1,
+    phi,
+    0,
+    -1,
+    -phi,
+    0,
+    1,
+    -phi,
+    phi,
+    0,
+    -1,
+    phi,
+    0,
+    1,
+    -phi,
+    0,
+    -1,
+    -phi,
+    0,
+    1
+  ];
+  let faces = [
+    0,
+    11,
+    5,
+    0,
+    5,
+    1,
+    0,
+    1,
+    7,
+    0,
+    7,
+    10,
+    0,
+    10,
+    11,
+    1,
+    5,
+    9,
+    5,
+    11,
+    4,
+    11,
+    10,
+    2,
+    10,
+    7,
+    6,
+    7,
+    1,
+    8,
+    3,
+    9,
+    4,
+    3,
+    4,
+    2,
+    3,
+    2,
+    6,
+    3,
+    6,
+    8,
+    3,
+    8,
+    9,
+    4,
+    9,
+    5,
+    2,
+    4,
+    11,
+    6,
+    2,
+    10,
+    8,
+    6,
+    7,
+    9,
+    8,
+    1
+  ];
+  const vertexCount = 10 * 4 ** detail + 2;
+  const pos = new Float64Array(vertexCount * 3);
+  let count = 0;
+  const add = (x, y, z) => {
+    const inv = 1 / Math.sqrt(x * x + y * y + z * z);
+    pos[count * 3] = x * inv;
+    pos[count * 3 + 1] = y * inv;
+    pos[count * 3 + 2] = z * inv;
+    return count++;
+  };
+  for (let i = 0; i < 12; i++) add(base[i * 3], base[i * 3 + 1], base[i * 3 + 2]);
+  for (let level = 0; level < detail; level++) {
+    const midpoints = /* @__PURE__ */ new Map();
+    const mid = (a, b) => {
+      const key = a < b ? a * vertexCount + b : b * vertexCount + a;
+      let m = midpoints.get(key);
+      if (m === void 0) {
+        m = add(
+          pos[a * 3] + pos[b * 3],
+          pos[a * 3 + 1] + pos[b * 3 + 1],
+          pos[a * 3 + 2] + pos[b * 3 + 2]
+        );
+        midpoints.set(key, m);
+      }
+      return m;
+    };
+    const next = [];
+    for (let f = 0; f < faces.length; f += 3) {
+      const a = faces[f];
+      const b = faces[f + 1];
+      const c = faces[f + 2];
+      const ab = mid(a, b);
+      const bc = mid(b, c);
+      const ca = mid(c, a);
+      next.push(a, ab, ca, b, bc, ab, c, ca, bc, ab, bc, ca);
+    }
+    faces = next;
+  }
+  const positions = new Float32Array(pos);
+  const indices = count > 65535 ? new Uint32Array(faces) : new Uint16Array(faces);
+  return { positions, normals: positions.slice(), indices };
+}
+const PRIMITIVES = {
+  box: (p) => box(p),
+  cube: (p) => cube(p),
+  sphere: (p) => sphere(p),
+  plane: (p) => plane(p),
+  cylinder: (p) => cylinder(p),
+  cone: (p) => cone(p),
+  capsule: (p) => capsule(p),
+  torus: (p) => torus(p)
+};
+function triangles(mesh) {
+  if (mesh.indices) return mesh.indices;
+  const n = mesh.positions.length / 3;
+  const out = n > 65535 ? new Uint32Array(n) : new Uint16Array(n);
+  for (let i = 0; i < n; i++) out[i] = i;
+  return out;
+}
+function computeNormals(mesh) {
+  const p = mesh.positions;
+  const tri = triangles(mesh);
+  const acc = new Float64Array(p.length);
+  for (let t = 0; t < tri.length; t += 3) {
+    const a = tri[t] * 3;
+    const b = tri[t + 1] * 3;
+    const c = tri[t + 2] * 3;
+    const ux = p[b] - p[a];
+    const uy = p[b + 1] - p[a + 1];
+    const uz = p[b + 2] - p[a + 2];
+    const vx = p[c] - p[a];
+    const vy = p[c + 1] - p[a + 1];
+    const vz = p[c + 2] - p[a + 2];
+    const nx = uy * vz - uz * vy;
+    const ny = uz * vx - ux * vz;
+    const nz = ux * vy - uy * vx;
+    for (const v of [a, b, c]) {
+      acc[v] = acc[v] + nx;
+      acc[v + 1] = acc[v + 1] + ny;
+      acc[v + 2] = acc[v + 2] + nz;
+    }
+  }
+  const normals = new Float32Array(p.length);
+  for (let v = 0; v < p.length; v += 3) {
+    const x = acc[v];
+    const y = acc[v + 1];
+    const z = acc[v + 2];
+    const len = Math.sqrt(x * x + y * y + z * z);
+    if (len > 0) {
+      normals[v] = x / len;
+      normals[v + 1] = y / len;
+      normals[v + 2] = z / len;
+    } else normals[v + 1] = 1;
+  }
+  return { ...mesh, normals };
+}
+function computeTangents(mesh) {
+  const p = mesh.positions;
+  const n = mesh.normals;
+  const uv = mesh.uvs;
+  const count = p.length / 3;
+  const out = new Float32Array(count * 4);
+  const tan = new Float64Array(count * 3);
+  const bit = new Float64Array(count * 3);
+  if (uv) {
+    const tri = triangles(mesh);
+    for (let t = 0; t < tri.length; t += 3) {
+      const a = tri[t];
+      const b = tri[t + 1];
+      const c = tri[t + 2];
+      const e1x = p[b * 3] - p[a * 3];
+      const e1y = p[b * 3 + 1] - p[a * 3 + 1];
+      const e1z = p[b * 3 + 2] - p[a * 3 + 2];
+      const e2x = p[c * 3] - p[a * 3];
+      const e2y = p[c * 3 + 1] - p[a * 3 + 1];
+      const e2z = p[c * 3 + 2] - p[a * 3 + 2];
+      const du1 = uv[b * 2] - uv[a * 2];
+      const dv1 = uv[b * 2 + 1] - uv[a * 2 + 1];
+      const du2 = uv[c * 2] - uv[a * 2];
+      const dv2 = uv[c * 2 + 1] - uv[a * 2 + 1];
+      const det = du1 * dv2 - du2 * dv1;
+      if (det === 0) continue;
+      const r = 1 / det;
+      const tx = (e1x * dv2 - e2x * dv1) * r;
+      const ty = (e1y * dv2 - e2y * dv1) * r;
+      const tz = (e1z * dv2 - e2z * dv1) * r;
+      const bx = (e2x * du1 - e1x * du2) * r;
+      const by = (e2y * du1 - e1y * du2) * r;
+      const bz = (e2z * du1 - e1z * du2) * r;
+      for (const v of [a, b, c]) {
+        tan[v * 3] = tan[v * 3] + tx;
+        tan[v * 3 + 1] = tan[v * 3 + 1] + ty;
+        tan[v * 3 + 2] = tan[v * 3 + 2] + tz;
+        bit[v * 3] = bit[v * 3] + bx;
+        bit[v * 3 + 1] = bit[v * 3 + 1] + by;
+        bit[v * 3 + 2] = bit[v * 3 + 2] + bz;
+      }
+    }
+  }
+  for (let v = 0; v < count; v++) {
+    const nx = n[v * 3];
+    const ny = n[v * 3 + 1];
+    const nz = n[v * 3 + 2];
+    let tx = tan[v * 3];
+    let ty = tan[v * 3 + 1];
+    let tz = tan[v * 3 + 2];
+    if (tx === 0 && ty === 0 && tz === 0) {
+      const ax = Math.abs(nx);
+      const ay = Math.abs(ny);
+      const az = Math.abs(nz);
+      if (ax <= ay && ax <= az) tx = 1;
+      else if (ay <= az) ty = 1;
+      else tz = 1;
+    }
+    const d = nx * tx + ny * ty + nz * tz;
+    tx -= nx * d;
+    ty -= ny * d;
+    tz -= nz * d;
+    const len = Math.sqrt(tx * tx + ty * ty + tz * tz) || 1;
+    tx /= len;
+    ty /= len;
+    tz /= len;
+    const cx = ny * tz - nz * ty;
+    const cy = nz * tx - nx * tz;
+    const cz = nx * ty - ny * tx;
+    const w = cx * bit[v * 3] + cy * bit[v * 3 + 1] + cz * bit[v * 3 + 2] < 0 ? -1 : 1;
+    out[v * 4] = tx;
+    out[v * 4 + 1] = ty;
+    out[v * 4 + 2] = tz;
+    out[v * 4 + 3] = w;
+  }
+  return out;
+}
+function cluster(mesh, cells) {
+  const p = mesh.positions;
+  const count = p.length / 3;
+  let minX = Infinity;
+  let minY = Infinity;
+  let minZ = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let maxZ = -Infinity;
+  for (let v = 0; v < count; v++) {
+    minX = Math.min(minX, p[v * 3]);
+    minY = Math.min(minY, p[v * 3 + 1]);
+    minZ = Math.min(minZ, p[v * 3 + 2]);
+    maxX = Math.max(maxX, p[v * 3]);
+    maxY = Math.max(maxY, p[v * 3 + 1]);
+    maxZ = Math.max(maxZ, p[v * 3 + 2]);
+  }
+  const size = Math.max(maxX - minX, maxY - minY, maxZ - minZ) || 1;
+  const cell = size / cells;
+  const map = new Int32Array(count);
+  const byKey = /* @__PURE__ */ new Map();
+  const sums = [];
+  const members = [];
+  for (let v = 0; v < count; v++) {
+    const ix = Math.min(cells - 1, Math.floor((p[v * 3] - minX) / cell));
+    const iy = Math.min(cells - 1, Math.floor((p[v * 3 + 1] - minY) / cell));
+    const iz = Math.min(cells - 1, Math.floor((p[v * 3 + 2] - minZ) / cell));
+    const key = (ix * cells + iy) * cells + iz;
+    let c = byKey.get(key);
+    if (c === void 0) {
+      c = members.length;
+      byKey.set(key, c);
+      members.push(0);
+      sums.push(0, 0, 0);
+    }
+    map[v] = c;
+    members[c] = members[c] + 1;
+    sums[c * 3] = sums[c * 3] + p[v * 3];
+    sums[c * 3 + 1] = sums[c * 3 + 1] + p[v * 3 + 1];
+    sums[c * 3 + 2] = sums[c * 3 + 2] + p[v * 3 + 2];
+  }
+  const tri = triangles(mesh);
+  const kept = [];
+  for (let t = 0; t < tri.length; t += 3) {
+    const a = map[tri[t]];
+    const b = map[tri[t + 1]];
+    const c = map[tri[t + 2]];
+    if (a !== b && b !== c && c !== a) kept.push(a, b, c);
+  }
+  const n = members.length;
+  const positions = new Float32Array(n * 3);
+  for (let c = 0; c < n; c++) {
+    positions[c * 3] = sums[c * 3] / members[c];
+    positions[c * 3 + 1] = sums[c * 3 + 1] / members[c];
+    positions[c * 3 + 2] = sums[c * 3 + 2] / members[c];
+  }
+  const out = {
+    positions,
+    indices: n > 65535 ? new Uint32Array(kept) : new Uint16Array(kept)
+  };
+  for (const [name, width] of [
+    ["uvs", 2],
+    ["colors", 4]
+  ]) {
+    const src = mesh[name];
+    if (!src) continue;
+    const acc = new Float64Array(n * width);
+    for (let v = 0; v < count; v++)
+      for (let k = 0; k < width; k++)
+        acc[map[v] * width + k] = acc[map[v] * width + k] + src[v * width + k];
+    const avg = new Float32Array(n * width);
+    for (let c = 0; c < n; c++)
+      for (let k = 0; k < width; k++) avg[c * width + k] = acc[c * width + k] / members[c];
+    out[name] = avg;
+  }
+  return out;
+}
+function simplify(mesh, fraction) {
+  const target = Math.max(4, Math.floor(triangles(mesh).length / 3 * fraction));
+  let lo = 1;
+  let hi = 256;
+  let best = cluster(mesh, 2);
+  for (let step = 0; step < 8 && lo <= hi; step++) {
+    const cells = lo + hi >> 1;
+    const candidate = cluster(mesh, cells);
+    const tris = (candidate.indices?.length ?? 0) / 3;
+    if (tris <= target) {
+      best = candidate;
+      lo = cells + 1;
+    } else hi = cells - 1;
+  }
+  return best;
+}
+function finish(mesh, options = {}) {
+  const withNormals = (m) => options.normals === true || !m.normals ? computeNormals(m) : m;
+  const withTangents = (m) => options.tangents ? { ...m, tangents: computeTangents(m) } : m;
+  const base = withTangents(withNormals(mesh));
+  const lods = [];
+  for (const fraction of options.lods ?? []) {
+    if (!(fraction > 0 && fraction < 1)) {
+      throw new ShardError("procgen/bad-mesh", `LOD fractions are in (0, 1), got ${fraction}`, {
+        hint: "lods: [0.5, 0.2] keeps about half, then a fifth, of the triangles."
+      });
+    }
+    lods.push(withTangents(computeNormals(simplify(mesh, fraction))));
+  }
+  return { kind: "mesh", mesh: base, lods };
+}
+const meshBuilder = {
+  icosphere,
+  primitive(name, params = {}) {
+    const make = PRIMITIVES[name];
+    if (!make) {
+      throw new ShardError("procgen/bad-mesh", `No primitive "${name}"`, {
+        hint: `Primitives: ${Object.keys(PRIMITIVES).join(", ")}.`
+      });
+    }
+    const data = make(params).data();
+    const out = { positions: data.positions.slice() };
+    if (data.normals) out.normals = data.normals.slice();
+    if (data.uvs) out.uvs = data.uvs.slice();
+    if (data.indices) out.indices = data.indices.slice();
+    return out;
+  },
+  computeNormals,
+  finish
+};
+export {
+  meshBuilder
+};

package/dist/methods.d.ts

@@ -0,0 +1,44 @@
+import { type JsonValue, type World } from '@aethervtt/shard-core';
+import { type PreviewImage } from '@aethervtt/shard-protocol';
+import type { AppMethod } from '@aethervtt/shard-runtime';
+import { type Generator, type GenRequest } from './generator.js';
+/**
+ * The generator a tool names: `star-explorer/Rock`, `scripts:Rock` or `Rock` (when one generator
+ * has that name), or a `*.gen.json` path (its seed and params become defaults).
+ */
+export declare function resolveGenerator(world: World, target: string): Promise<{
+    gen: Generator;
+    seed?: number;
+    params: Record<string, JsonValue>;
+    file?: string;
+}>;
+export interface RunSummary {
+    generator: string;
+    output: string;
+    path: string;
+    guid: string;
+    key: string | undefined;
+    seed: number;
+    /** Whether the output came from a cache (memory, disk, or already loaded) instead of a run. */
+    cacheHit: boolean;
+    hit: string;
+    /** Generation time (the original run's, on a cache hit), ms. */
+    ms: number;
+    vertices?: number;
+    triangles?: number;
+    bounds?: JsonValue;
+    lods?: JsonValue;
+    texture?: JsonValue;
+    entities?: number;
+    components?: JsonValue;
+    generated?: number;
+    warnings: {
+        message: string;
+        path?: string;
+    }[];
+}
+/** Makes (or finds) an output and summarizes it. */
+export declare function runGenerator(world: World, request: GenRequest): Promise<RunSummary>;
+/** A picture of one output: rendered meshes and entities, textures as they are. */
+export declare function previewOutput(world: World, request: GenRequest, size: number): Promise<PreviewImage>;
+export declare const procgenMethods: AppMethod[];

package/dist/methods.js

@@ -0,0 +1,212 @@
+import { assetServer } from "@aethervtt/shard-assets";
+import {
+  defineSchema,
+  isPlainObject,
+  ShardError,
+  t
+} from "@aethervtt/shard-core";
+import {
+  encodePng,
+  previewAsset,
+  previewKtx2,
+  toBase64
+} from "@aethervtt/shard-protocol";
+import {
+  allGenerators,
+  codeHashOf,
+  findGenerator,
+  requestOf
+} from "./generator.js";
+import { GeneratorBindings, procgen, procgenHost } from "./runtime.js";
+import { contactSheet, parseSeeds } from "./sheet.js";
+async function resolveGenerator(world, target2) {
+  if (target2.includes(".gen.json")) {
+    const file = target2.split("#")[0];
+    const server = assetServer(world);
+    const entry = server.entry(`${file}#Generator`);
+    if (!entry) {
+      throw new ShardError(
+        "procgen/unknown-generator",
+        `No generator file "${file}" in the catalog`,
+        {
+          hint: "Check the path, or run `shard import` for new files."
+        }
+      );
+    }
+    await server.load(entry.guid);
+    const binding = world.resource(GeneratorBindings).get(entry);
+    const gen = findGenerator(binding.generator);
+    if (!gen) {
+      throw new ShardError("procgen/unknown-generator", `No generator "${binding.generator}"`, {
+        path: `${file}/generator`
+      });
+    }
+    return { gen, seed: binding.seed, params: binding.params ?? {}, file };
+  }
+  const name = target2.startsWith("scripts:") ? target2.slice("scripts:".length) : target2;
+  const exact = findGenerator(name);
+  if (exact) return { gen: exact, params: {} };
+  const matches = allGenerators().filter((g) => g.name.endsWith(`/${name}`));
+  if (matches.length === 1) return { gen: matches[0], params: {} };
+  throw new ShardError("procgen/unknown-generator", `No generator "${target2}"`, {
+    hint: matches.length ? `Several match: ${matches.map((g) => g.name).join(", ")}.` : `Generators: ${allGenerators().map((g) => g.name).join(", ") || "(none)"}.`
+  });
+}
+function paramsOf(value, flag = "params") {
+  if (value === void 0 || value === null) return {};
+  if (!isPlainObject(value)) {
+    throw new ShardError("procgen/bad-params", `"${flag}" must be an object of param values`, {
+      path: `/${flag}`
+    });
+  }
+  return value;
+}
+async function runGenerator(world, request) {
+  const runtime = procgen(world);
+  const gen = findGenerator(request.generator);
+  const entry = runtime.entryFor(request);
+  const wasLoaded = entry.state === "loaded";
+  await assetServer(world).load(entry.guid);
+  const last = runtime.lastResult(entry.guid);
+  const record = runtime.recordOf(entry.guid);
+  const main = record?.assets.find((a) => a.label === "");
+  const info = main?.info ?? {};
+  const hit = wasLoaded ? "loaded" : last?.hit ?? "run";
+  const out = {
+    generator: gen.name,
+    output: gen.outputType,
+    path: entry.path,
+    guid: entry.guid,
+    key: last?.key,
+    seed: request.seed,
+    cacheHit: hit !== "run",
+    hit,
+    ms: Math.round((last?.ms ?? 0) * 100) / 100,
+    warnings: record?.warnings ?? []
+  };
+  if (gen.output === "mesh") {
+    out.vertices = info.vertices;
+    out.triangles = info.triangles;
+    out.bounds = info.bounds;
+    if (info.lods) out.lods = info.lods;
+  } else if (gen.output === "texture") {
+    out.texture = { width: info.width, height: info.height, usage: info.usage, mips: info.mips };
+  } else if (gen.output === "entities") {
+    out.entities = info.entities;
+    out.components = info.components;
+  }
+  if (record && record.children.length > 0) out.generated = record.children.length;
+  return out;
+}
+async function previewOutput(world, request, size) {
+  const runtime = procgen(world);
+  const gen = findGenerator(request.generator);
+  const entry = runtime.entryFor(request);
+  await assetServer(world).load(entry.guid);
+  if (gen.output === "texture") {
+    const bytes = runtime.recordOf(entry.guid)?.assets.find((a) => a.label === "")?.bytes;
+    if (bytes) return previewKtx2(bytes, size, size);
+  }
+  if (gen.output === "data") {
+    throw new ShardError("procgen/no-preview", `${gen.name} makes data; there's nothing to draw`, {
+      hint: "procgen.run returns the value summary; asset.get shows it."
+    });
+  }
+  return previewAsset(world, entry.path, size, size);
+}
+const target = t.string({
+  required: true,
+  description: 'A generator ("star-explorer/Rock", or "Rock" when unique) or a *.gen.json path, whose seed and params become defaults.'
+});
+const procgenMethods = [
+  {
+    name: "procgen.run",
+    description: "Runs a generator (or finds its cached output) and summarizes it: output type, cache key, time, whether it was a cache hit, vertex and triangle counts and bounds (meshes), size (textures), entities and components (entities), nested outputs, warnings. The output is an asset at the returned path (procedural:\u2026).",
+    params: defineSchema("procgen/RunParams", {
+      generator: target,
+      params: t.json({ description: "Param values; missing ones take the defaults." }),
+      seed: t.u32({ description: "The seed (default: the file's, or 0)." })
+    }),
+    handler: async ({ world }, p) => {
+      const found = await resolveGenerator(world, p.generator);
+      const params = { ...found.params, ...paramsOf(p.params) };
+      const seed = p.seed || found.seed || 0;
+      return runGenerator(world, requestOf(found.gen, params, seed));
+    }
+  },
+  {
+    name: "procgen.preview",
+    description: 'A PNG of a generator output: a mesh in a neutral studio light from a three-quarter view, a texture as is, entities as a scene framed on their bounds. With seeds ("1-9" or [1, 4, 9]) it is a labelled contact sheet, one cell per seed: change a param, preview nine seeds, compare.',
+    params: defineSchema("procgen/PreviewParams", {
+      generator: target,
+      params: t.json({ description: "Param values." }),
+      seed: t.u32({ description: "The seed, without seeds." }),
+      seeds: t.json({ description: 'Seeds for a contact sheet: "1-9", "1,5,9", or [1, 5, 9].' }),
+      size: t.u32({ default: 256, min: 32, max: 1024, description: "Pixels per cell." })
+    }),
+    handler: async ({ world }, p) => {
+      const found = await resolveGenerator(world, p.generator);
+      const params = { ...found.params, ...paramsOf(p.params) };
+      const size = p.size;
+      const seeds = p.seeds === void 0 || p.seeds === null ? void 0 : parseSeeds(p.seeds);
+      let image;
+      const keys = [];
+      if (seeds && seeds.length > 0) {
+        const images = [];
+        for (const seed of seeds) {
+          const request = requestOf(found.gen, params, seed);
+          images.push(await previewOutput(world, request, size));
+          const guid = procgen(world).entryFor(request).guid;
+          keys.push(procgen(world).lastResult(guid)?.key ?? "");
+        }
+        image = contactSheet(
+          images,
+          seeds.map((s) => `seed ${s}`),
+          size
+        );
+      } else {
+        const request = requestOf(found.gen, params, p.seed || found.seed || 0);
+        image = await previewOutput(world, request, size);
+        keys.push(procgen(world).lastResult(procgen(world).entryFor(request).guid)?.key ?? "");
+      }
+      const png = await encodePng(image.data, image.width, image.height);
+      return {
+        width: image.width,
+        height: image.height,
+        data: toBase64(png),
+        generator: found.gen.name,
+        ...seeds ? { seeds } : {},
+        keys
+      };
+    }
+  },
+  {
+    name: "procgen.describe",
+    description: "Every generator (params schema with units and ranges, output type, version, code hash), the output cache (records, bytes, limit), counts of runs and cache hits, jobs running now, and whether jobs run on workers.",
+    params: defineSchema("procgen/DescribeParams", {}),
+    handler: ({ world }) => {
+      const runtime = procgen(world);
+      const host = procgenHost();
+      return {
+        generators: allGenerators().map((g) => ({
+          name: g.name,
+          ...g.description ? { description: g.description } : {},
+          output: g.outputType,
+          version: g.version,
+          codeHash: codeHashOf(g),
+          params: g.params.jsonSchema()
+        })),
+        cache: runtime.cacheStats(),
+        stats: { ...runtime.stats, mainMs: Math.round(runtime.stats.mainMs * 100) / 100 },
+        inFlight: runtime.inFlight(),
+        workers: host.workers && host.workerModule ? host.workers.size : 0
+      };
+    }
+  }
+];
+export {
+  previewOutput,
+  procgenMethods,
+  resolveGenerator,
+  runGenerator
+};

package/dist/outputs.d.ts

@@ -0,0 +1,22 @@
+import { type JsonValue } from '@aethervtt/shard-core';
+import type { Generator } from './generator.js';
+/** One asset a generator run made: the main output ('') or a sub-asset (`LOD1`). */
+export interface GenOutputAsset {
+    label: string;
+    type: string;
+    bytes?: Uint8Array;
+    json?: JsonValue;
+    info?: Record<string, JsonValue>;
+}
+/** Plain JSON of a value: refs lose their `type`, typed arrays become arrays. */
+export declare function toJson(value: unknown): JsonValue;
+/**
+ * Turns what `run` returned into artifacts, checking it's the generator's output type. With
+ * `checkComponents: false`, entities' components aren't checked against their schemas (a worker
+ * whose bundle may predate the current schemas; the caller checks with `checkFragment`).
+ */
+export declare function encodeOutput(gen: Generator, value: unknown, options?: {
+    checkComponents?: boolean;
+}): GenOutputAsset[];
+/** Checks an `entities` artifact's components against this thread's schemas; throws like `run`. */
+export declare function checkFragment(gen: Generator, asset: GenOutputAsset): void;