@developerz.ai/ts23d 0.1.0 → 0.2.0

package/src/export/glb.ts

@@ -2,71 +2,59 @@
 // with its pivot as translation, and each part's motion baked as a looping animation clip.
 // Extras a stock viewer understands: light sockets → KHR_lights_punctual, glowing parts →
 // emissive (+ KHR_materials_emissive_strength), provenance → asset.copyright + KHR_xmp_json_ld.
-// Zero dependencies and byte-deterministic: same CompiledAsset in, same bytes out.
+// `exportLodGlb` packs several LODs into ONE file (MSFT_lod alternates sharing materials,
+// textures and motion samplers). Zero dependencies and byte-deterministic.
 
 import type { CompiledAsset, Part } from '../core/index.ts';
-import { quatFromAxisAngle, Ts23dError } from '../core/index.ts';
-import type { OptimizeOptions } from '../passes/index.ts';
+import { Ts23dError } from '../core/index.ts';
 import { BinWriter, type Json } from './bin-writer.ts';
 import { concat, packGlb } from './container.ts';
-import { LIGHTS, lightOf } from './lights.ts';
+import { withCredits } from './credits.ts';
+import type { GlbOptions, GlbResult, LodGlbResult } from './glb-options.ts';
+import { newDoc, writeHierarchy } from './hierarchy.ts';
+import { LIGHTS } from './lights.ts';
+import {
+  checkCoverage,
+  coverageFor,
+  defaultCoverage,
+  MSFT_LOD,
+  SCREEN_COVERAGE,
+} from './lod-coverage.ts';
 import { EMISSIVE_STRENGTH, type GlowRule, glowMaterial, materialsFor } from './materials.ts';
 import { globRe, glowLayer, mergeToPivots } from './merge-pivots.ts';
-import { type GlbMeta, metadata } from './metadata.ts';
-import { motionChannel } from './motion.ts';
-import { type ExportReport, optimizeParts } from './optimize-parts.ts';
-import { writePrimitive } from './primitive.ts';
-import { type SheetBinding, sheetGltf } from './textures.ts';
+import { metadata } from './metadata.ts';
+import { optimizeParts, summarize } from './optimize-parts.ts';
+import { sheetGltf } from './textures.ts';
 
 // Viewers auto-play the FIRST clip and glTF has no "paused" flag, so the first clip is `rest`: two
 // keys holding the root's rest rotation. The file opens still; pick `run` to play it.
 // Authoring frame: Z up, +X front. glTF: Y up, +Z front, +X = the asset's left. This root
 // rotation maps +X→+Z, +Z→+Y, +Y→+X (verified numerically), so assets face forward in engines.
 const Z_UP_TO_Y_UP = [-0.5, -0.5, -0.5, 0.5];
-function restClip(bin: BinWriter): Json {
+function restClip(bin: BinWriter, roots: readonly number[]): Json {
   const input = bin.accessor(new Float32Array([0, 1]), 'SCALAR', undefined, true);
   const output = bin.accessor(new Float32Array([...Z_UP_TO_Y_UP, ...Z_UP_TO_Y_UP]), 'VEC4');
   return {
     name: 'rest',
     samplers: [{ input, output, interpolation: 'STEP' }],
-    channels: [{ sampler: 0, target: { node: 0, path: 'rotation' } }],
+    channels: roots.map((node) => ({ sampler: 0, target: { node, path: 'rotation' } })),
   };
 }
 
-export interface GlbOptions {
-  /** Keep every part as its own node (debugging, per-part picking). Default merges to pivots. */
-  readonly keepParts?: boolean;
-  /**
-   * Bake each part's `motion` into a looping `run` clip. Off by default: glTF has no autoplay
-   * flag and most viewers play the first clip, while engines usually drive the named pivots
-   * from game code. Turn it on for previews, cutscenes and ambient props.
-   */
-  readonly animations?: boolean;
-  /**
-   * Bind the painted trim sheet to every material: a `PaintedSheet` embeds the three PNGs (one
-   * self-contained file); `{ external: true, prefix? }` references shared `trim_sheet_*.png` by
-   * URI. Omitted: no textures, byte-identical to the untextured output.
-   */
-  readonly sheet?: SheetBinding;
-  /**
-   * Weld + vertex-cache + vertex-fetch optimisation per primitive (passes/optimize). On by
-   * default; `false` writes the meshes exactly as compiled (debugging the IR).
-   */
-  readonly optimize?: boolean | OptimizeOptions;
-  /** Parts that emit light (lamp lenses, lit windows): one emissive material per rule. */
-  readonly glow?: readonly GlowRule[];
-  /** Provenance: asset.copyright + an XMP packet (title, creators, licence, sources). */
-  readonly meta?: GlbMeta;
+export type { GlbOptions, GlbResult, LodGlbResult } from './glb-options.ts';
+
+export function toGlb(input: CompiledAsset, o: GlbOptions = {}): Uint8Array {
+  return exportGlb(input, o).glb;
 }
 
-/** The GLB bytes plus what the optimiser did (vertex counts, ACMR before/after, per part). */
-export interface GlbResult {
-  readonly glb: Uint8Array;
-  readonly report: ExportReport;
+export function exportGlb(input: CompiledAsset, o: GlbOptions = {}): GlbResult {
+  const { glb, reports } = exportLodGlb([input], o);
+  return { glb, report: reports[0] ?? summarize([], false) };
 }
 
-export function toGlb(input: CompiledAsset, o: GlbOptions = {}): Uint8Array {
-  return exportGlb(input, o).glb;
+/** All LODs in one GLB: LOD0 in the scene, the rest as MSFT_lod alternates outside it. */
+export function toLodGlb(lods: readonly CompiledAsset[], o: GlbOptions = {}): Uint8Array {
+  return exportLodGlb(lods, o).glb;
 }
 
 function checkGlow(rules: readonly GlowRule[]): void {
@@ -78,9 +66,22 @@ function checkGlow(rules: readonly GlowRule[]): void {
       });
 }
 
-export function exportGlb(input: CompiledAsset, o: GlbOptions = {}): GlbResult {
-  const glow = o.glow ?? input.glow ?? [];
-  checkGlow(glow);
+function checkLods(lods: readonly CompiledAsset[]): void {
+  const names = new Set(lods.map((l) => l.name));
+  const levels = lods.map((l) => l.lod);
+  if (
+    lods.length === 0 ||
+    names.size !== 1 ||
+    levels.some((l, i) => i > 0 && l <= (levels[i - 1] ?? 0))
+  )
+    throw new Ts23dError('T3D_RECIPE_INVALID', {
+      cause: `exportLodGlb got LODs [${levels.join(', ')}] of [${[...names].join(', ')}]`,
+      fix: 'pass compile(asset, { lod }) results of ONE asset, highest detail first: LOD0, LOD1, LOD2',
+    });
+}
+
+/** One LOD prepared for writing: merged + optimised parts and its glow-layer lookup. */
+function prepare(input: CompiledAsset, o: GlbOptions, glow: readonly GlowRule[]) {
   const opt = o.optimize === false ? false : o.optimize === true ? {} : (o.optimize ?? {});
   const merged = o.keepParts
     ? input
@@ -94,101 +95,87 @@ export function exportGlb(input: CompiledAsset, o: GlbOptions = {}): GlbResult {
   const glowOf = (p: Part, i: number): number =>
     glowLayer.get(merged.parts[i] ?? p) ??
     (o.keepParts ? glowRes.findIndex((rs) => rs.some((r) => r.test(p.name))) : -1);
+  return { asset, report, glowOf };
+}
+
+export function exportLodGlb(lods: readonly CompiledAsset[], o: GlbOptions = {}): LodGlbResult {
+  checkLods(lods);
+  const top = lods[0] as CompiledAsset;
+  const glow = o.glow ?? top.glow ?? [];
+  checkGlow(glow);
+  const preps = lods.map((l) => prepare(l, o, glow));
+  const withSheet = o.sheet !== undefined;
   const mats = materialsFor(
-    new Set(asset.parts.flatMap((p) => (p.surface ? [p.surface] : []))),
-    o.sheet !== undefined,
+    new Set(preps.flatMap((p) => p.asset.parts.flatMap((q) => (q.surface ? [q.surface] : [])))),
+    withSheet,
   );
   const glowAt = mats.materials.length;
-  const materials = [
-    ...mats.materials,
-    ...glow.map((g, i) => glowMaterial(g, i, o.sheet !== undefined)),
-  ];
-  const bin = new BinWriter();
-  const meshes: Json[] = [];
-  const nodes: Json[] = [{ name: asset.name, children: [] as number[] }];
-  const index = new Map<string, number>();
-  const samplers: Json[] = [];
-  const channels: Json[] = [];
-  const lights: Json[] = [];
-  const attach = (parentId: number, id: number): void => {
-    const parent = nodes[parentId];
-    if (!parent) return;
-    parent['children'] = [...((parent['children'] as number[] | undefined) ?? []), id];
-  };
-
-  asset.parts.forEach((part: Part, i) => {
-    const node: Json = { name: part.name, translation: [...part.at] };
-    if (part.yaw) node['rotation'] = [...quatFromAxisAngle([0, 0, 1], part.yaw)];
-    if (part.emitter || part.socket) {
-      node['extras'] = {
-        ts23d: {
-          ...(part.emitter ? { emitter: part.emitter } : {}),
-          ...(part.socket ? { socket: part.socket } : {}),
-        },
-      };
-    }
-    if (part.mesh && part.mesh.indices.length > 0) {
-      const g = glowOf(part, i);
-      const material = g >= 0 ? glowAt + g : (mats.index.get(part.surface ?? 'opaque') ?? 0);
-      meshes.push({
-        name: part.name,
-        primitives: [writePrimitive(bin, part.mesh, material, o.sheet !== undefined)],
-      });
-      node['mesh'] = meshes.length - 1;
-    }
-    nodes.push(node);
-    const id = nodes.length - 1;
-    index.set(part.name, id);
-    attach(part.parent === null ? 0 : (index.get(part.parent) ?? 0), id);
-    const lit = lightOf(part);
-    if (lit) {
-      lights.push(lit.light);
-      nodes.push({
-        name: `${part.name}_light`,
-        rotation: [...lit.rotation],
-        extensions: { [LIGHTS]: { light: lights.length - 1 } },
-      });
-      attach(id, nodes.length - 1);
-    }
-    if (part.motion && o.animations) {
-      const { sampler, channel } = motionChannel(bin, part.motion, id, part.at);
-      samplers.push(sampler);
-      channels.push({ ...channel, sampler: samplers.length - 1 });
-    }
-  });
+  const materials = [...mats.materials, ...glow.map((g, i) => glowMaterial(g, i, withSheet))];
+  const doc = newDoc(new BinWriter());
+  const roots = preps.map(({ asset, glowOf }, k) =>
+    writeHierarchy(doc, asset, k === 0 ? asset.name : `${asset.name}_LOD${asset.lod}`, {
+      withSheet,
+      animations: o.animations === true,
+      materialOf: (part, i) => {
+        const g = glowOf(part, i);
+        return g >= 0 ? glowAt + g : (mats.index.get(part.surface ?? 'opaque') ?? 0);
+      },
+    }),
+  );
+  for (const r of roots) {
+    const node = doc.nodes[r];
+    if (node) node['rotation'] = Z_UP_TO_Y_UP;
+  }
+  const coverage: number[] = [];
+  const rootNode = doc.nodes[0];
+  if (roots.length > 1 && rootNode) {
+    const c = o.lodCoverage ?? top.lodCoverage ?? defaultCoverage(lods);
+    checkCoverage(c, top.name);
+    coverage.push(
+      ...coverageFor(
+        lods.map((l) => l.lod),
+        c,
+      ),
+    );
+    // Alternates stay OUT of the scene's root list: a viewer without MSFT_lod shows LOD0 only.
+    rootNode['extensions'] = { [MSFT_LOD]: { ids: roots.slice(1) } };
+    rootNode['extras'] = { [SCREEN_COVERAGE]: coverage };
+  }
 
   // Every accessor — the rest clip's included — must be written BEFORE the buffer is sealed.
-  const animations = channels.length ? [restClip(bin), { name: 'run', samplers, channels }] : [];
+  const { bin, lights, samplers, channels } = doc;
+  const animations = channels.length
+    ? [restClip(bin, roots), { name: 'run', samplers, channels }]
+    : [];
   const geometry = bin.bytes();
   const tex = o.sheet ? sheetGltf(o.sheet, bin.views, geometry.byteLength) : null;
   const body = tex?.tail.byteLength ? concat(geometry, tex.tail) : geometry;
-  const meta = metadata(asset.name, o.meta ?? input.meta);
+  const meta = metadata(top.name, withCredits(top, o.meta ?? top.meta));
   const used = [
     ...mats.extensionsUsed,
     ...(glow.some((g) => (g.strength ?? 4) !== 1) ? [EMISSIVE_STRENGTH] : []),
     ...(lights.length ? [LIGHTS] : []),
+    ...(coverage.length ? [MSFT_LOD] : []),
     ...meta.used,
   ].sort();
   const extensions: Json = {
     ...(lights.length ? { [LIGHTS]: { lights } } : {}),
     ...(meta.extensions ?? {}),
   };
-  const root = nodes[0];
-  if (root) root['rotation'] = Z_UP_TO_Y_UP;
   const gltf: Json = {
     asset: meta.asset,
     extras: {
-      kind: asset.kind,
-      lod: asset.lod,
+      kind: top.kind,
+      lod: coverage.length ? lods.map((l) => l.lod) : top.lod,
       units: 'metres',
       up: 'Z (rotated to glTF Y-up at the root)',
     },
     ...(used.length ? { extensionsUsed: used } : {}),
     ...(Object.keys(extensions).length ? { extensions } : {}),
     scene: 0,
-    scenes: [{ name: asset.name, nodes: [0] }],
-    nodes,
-    meshes,
+    scenes: [{ name: top.name, nodes: [0] }],
+    nodes: doc.nodes,
+    meshes: doc.meshes,
     materials,
     ...(tex ? tex.json : {}),
     buffers: [{ byteLength: body.byteLength }],
@@ -196,5 +183,5 @@ export function exportGlb(input: CompiledAsset, o: GlbOptions = {}): GlbResult {
     accessors: bin.accessors,
     ...(animations.length ? { animations } : {}),
   };
-  return { glb: packGlb(gltf, body), report };
+  return { glb: packGlb(gltf, body), reports: preps.map((p) => p.report), coverage };
 }

package/src/export/hierarchy.ts

@@ -0,0 +1,122 @@
+// Writes one LOD's node tree into a shared glTF document: a root node, one node per (merged) part
+// with its pivot as translation, light nodes under light sockets, meshes, and the part motions as
+// `run` channels. Called once per LOD; the bin, materials, lights and motion samplers are shared,
+// so a single-file GLB stores each identical motion and light only once.
+
+import type { CompiledAsset, Part } from '../core/index.ts';
+import { quatFromAxisAngle } from '../core/index.ts';
+import type { BinWriter, Json } from './bin-writer.ts';
+import { LIGHTS, lightOf } from './lights.ts';
+import { motionChannel } from './motion.ts';
+import { writePrimitive } from './primitive.ts';
+
+/** The growing glTF arrays every LOD appends to. */
+export interface GltfDoc {
+  readonly bin: BinWriter;
+  readonly nodes: Json[];
+  readonly meshes: Json[];
+  readonly lights: Json[];
+  readonly samplers: Json[];
+  readonly channels: Json[];
+  /** motion + rest pose → sampler index: the same wheel spin at LOD0 and LOD1 is one sampler. */
+  readonly motionSamplers: Map<string, number>;
+  readonly lightIndex: Map<string, number>;
+}
+
+export const newDoc = (bin: BinWriter): GltfDoc => ({
+  bin,
+  nodes: [],
+  meshes: [],
+  lights: [],
+  samplers: [],
+  channels: [],
+  motionSamplers: new Map(),
+  lightIndex: new Map(),
+});
+
+export interface HierarchyOptions {
+  /** Material index for a part (trim sheet by surface, or its glow layer). */
+  readonly materialOf: (part: Part, i: number) => number;
+  readonly withSheet: boolean;
+  readonly animations: boolean;
+}
+
+function attach(doc: GltfDoc, parentId: number, id: number): void {
+  const parent = doc.nodes[parentId];
+  if (!parent) return;
+  parent['children'] = [...((parent['children'] as number[] | undefined) ?? []), id];
+}
+
+function lightIndexOf(doc: GltfDoc, light: Json): number {
+  const key = JSON.stringify(light);
+  const known = doc.lightIndex.get(key);
+  if (known !== undefined) return known;
+  doc.lights.push(light);
+  doc.lightIndex.set(key, doc.lights.length - 1);
+  return doc.lights.length - 1;
+}
+
+function addMotion(doc: GltfDoc, part: Part, id: number): void {
+  if (!part.motion) return;
+  const key = JSON.stringify([part.motion, part.at]);
+  let sampler = doc.motionSamplers.get(key);
+  let channel: Json;
+  if (sampler === undefined) {
+    const written = motionChannel(doc.bin, part.motion, id, part.at);
+    doc.samplers.push(written.sampler);
+    sampler = doc.samplers.length - 1;
+    doc.motionSamplers.set(key, sampler);
+    channel = written.channel;
+  } else {
+    channel = {
+      target: { node: id, path: part.motion.kind === 'slide' ? 'translation' : 'rotation' },
+    };
+  }
+  doc.channels.push({ ...channel, sampler });
+}
+
+/** Appends `asset`'s tree under a new root named `rootName`; returns the root node index. */
+export function writeHierarchy(
+  doc: GltfDoc,
+  asset: CompiledAsset,
+  rootName: string,
+  o: HierarchyOptions,
+): number {
+  doc.nodes.push({ name: rootName, children: [] as number[] });
+  const root = doc.nodes.length - 1;
+  const index = new Map<string, number>();
+  asset.parts.forEach((part: Part, i) => {
+    const node: Json = { name: part.name, translation: [...part.at] };
+    if (part.yaw) node['rotation'] = [...quatFromAxisAngle([0, 0, 1], part.yaw)];
+    if (part.emitter || part.socket) {
+      node['extras'] = {
+        ts23d: {
+          ...(part.emitter ? { emitter: part.emitter } : {}),
+          ...(part.socket ? { socket: part.socket } : {}),
+        },
+      };
+    }
+    if (part.mesh && part.mesh.indices.length > 0) {
+      doc.meshes.push({
+        name: part.name,
+        primitives: [writePrimitive(doc.bin, part.mesh, o.materialOf(part, i), o.withSheet)],
+      });
+      node['mesh'] = doc.meshes.length - 1;
+    }
+    doc.nodes.push(node);
+    const id = doc.nodes.length - 1;
+    index.set(part.name, id);
+    attach(doc, part.parent === null ? root : (index.get(part.parent) ?? root), id);
+    const lit = lightOf(part);
+    if (lit) {
+      doc.nodes.push({
+        name: `${part.name}_light`,
+        rotation: [...lit.rotation],
+        extensions: { [LIGHTS]: { light: lightIndexOf(doc, lit.light) } },
+      });
+      attach(doc, id, doc.nodes.length - 1);
+    }
+    if (o.animations) addMotion(doc, part, id);
+  });
+  return root;
+}

package/src/export/index.ts

@@ -1,6 +1,22 @@
 // Public API of /export: back ends that turn a CompiledAsset into a file.
 
-export { exportGlb, type GlbOptions, type GlbResult, toGlb } from './glb.ts';
+export {
+  exportGlb,
+  exportLodGlb,
+  type GlbOptions,
+  type GlbResult,
+  type LodGlbResult,
+  toGlb,
+  toLodGlb,
+} from './glb.ts';
+export {
+  checkCoverage,
+  coverageFor,
+  defaultCoverage,
+  type LodCoverage,
+  MSFT_LOD,
+  SCREEN_COVERAGE,
+} from './lod-coverage.ts';
 export { mergeToPivots } from './merge-pivots.ts';
 export {
   type ExportReport,

package/src/export/lod-coverage.ts

@@ -0,0 +1,71 @@
+// View-distance hints for the single-file GLB: MSFT_lod (vendor extension, node level) on the
+// LOD0 root lists the LOD1/LOD2 roots, and `extras.MSFT_screencoverage` holds, per LOD, the
+// screen-height fraction below which the next LOD (or nothing) takes over — Unity LODGroup's
+// "screen relative transition height". Spec: KhronosGroup/glTF extensions/2.0/Vendor/MSFT_lod.
+//
+// Default thresholds match screen-space triangle density: a LOD with r × the triangles looks as
+// dense at √r × the size on screen (triangles per pixel ∝ tris / coverage²). Landmarks (≥ 10 m)
+// cull later than props, so a building stays on the skyline.
+
+import type { CompiledAsset } from '../core/index.ts';
+import { Ts23dError, worldMeshes } from '../core/index.ts';
+
+export const MSFT_LOD = 'MSFT_lod';
+export const SCREEN_COVERAGE = 'MSFT_screencoverage';
+
+export type LodCoverage = readonly [number, number, number];
+
+const tris = (a: CompiledAsset): number =>
+  a.parts.reduce((s, p) => s + (p.mesh ? p.mesh.indices.length / 3 : 0), 0);
+
+/** Largest extent in metres: `real` when declared, else the LOD0 world bounds. */
+function extent(a: CompiledAsset): number {
+  if (a.real) return Math.max(a.real.length, a.real.width, a.real.height);
+  const lo = [Infinity, Infinity, Infinity];
+  const hi = [-Infinity, -Infinity, -Infinity];
+  for (const mesh of worldMeshes(a.parts).values()) {
+    const p = mesh.positions;
+    for (let i = 0; i < p.length; i++) {
+      const k = i % 3;
+      const v = p[i] ?? 0;
+      lo[k] = Math.min(lo[k] ?? 0, v);
+      hi[k] = Math.max(hi[k] ?? 0, v);
+    }
+  }
+  return Math.max(0, ...hi.map((h, k) => h - (lo[k] ?? 0)));
+}
+
+const clamp = (v: number, lo: number, hi: number): number => Math.min(hi, Math.max(lo, v));
+const round = (v: number): number => Math.round(v * 1000) / 1000;
+
+/** Default [LOD0→1, LOD1→2, cull] for an asset from its compiled LODs (any subset, LOD0 first). */
+export function defaultCoverage(lods: readonly CompiledAsset[]): LodCoverage {
+  const byLod = new Map<number, number>(lods.map((a) => [a.lod, tris(a)]));
+  const top = lods[0];
+  const t0 = Math.max(1, top ? tris(top) : 1);
+  const ratio = (lod: number): number => (byLod.get(lod) ?? t0) / t0;
+  const c1 = round(clamp(Math.sqrt(ratio(1)), 0.1, 0.6));
+  const c2 = round(clamp(Math.sqrt(ratio(2)), 0.02, c1 / 2));
+  const cull = top && extent(top) >= 10 ? 0.002 : 0.01;
+  return [c1, c2, Math.min(cull, round(c2 / 2))];
+}
+
+export function checkCoverage(c: readonly number[], asset: string): void {
+  const [a = -1, b = -1, cull = -1] = c;
+  if (c.length !== 3 || !(a < 1 && a > b && b > cull && cull >= 0))
+    throw new Ts23dError('T3D_RECIPE_INVALID', {
+      cause: `lodCoverage ${JSON.stringify(c)} on '${asset}' is not strictly descending in [0, 1)`,
+      fix: 'give [LOD0→LOD1, LOD1→LOD2, cull] screen-height fractions, e.g. [0.5, 0.2, 0.01]; 0 = never cull',
+    });
+}
+
+/**
+ * MSFT_screencoverage for the LODs actually written (e.g. [0, 2]): entry j is the coverage where
+ * LOD j hands over — to the next included LOD's switch point, or to nothing (cull) for the last.
+ */
+export function coverageFor(levels: readonly number[], c: LodCoverage): number[] {
+  return levels.map((_, j) => {
+    const next = levels[j + 1];
+    return next === undefined ? c[2] : (c[next - 1] ?? c[2]);
+  });
+}

package/src/export/metadata.ts

@@ -17,6 +17,8 @@ export interface GlbMeta {
   readonly license?: string;
   /** Where the numbers came from (the recipe's `sources`) → `dc:relation`. */
   readonly sources?: readonly string[];
+  /** Third-party inputs (e.g. CC0 texture sets) → `dc:contributor`. Filled by export. */
+  readonly credits?: readonly string[];
 }
 
 const XMP = 'KHR_xmp_json_ld';
@@ -49,6 +51,7 @@ export function metadata(
     ...(meta.copyright ? { 'dc:rights': alt(meta.copyright) } : {}),
     ...(meta.license ? { 'xmpRights:UsageTerms': alt(meta.license) } : {}),
     ...(meta.sources?.length ? { 'dc:relation': { '@set': [...meta.sources] } } : {}),
+    ...(meta.credits?.length ? { 'dc:contributor': { '@set': [...meta.credits] } } : {}),
     'xmp:CreatorTool': GENERATOR,
   };
   return {

package/src/export/version.ts

@@ -2,5 +2,5 @@
 // constant because the library may not import package.json (rootDir is src); version.test.ts
 // fails the gate when the two disagree, and `bun run release` stamps both.
 
-export const VERSION = '0.1.0';
+export const VERSION = '0.2.0';
 export const GENERATOR = `@developerz.ai/ts23d ${VERSION}`;