@neta-art/cohub 5.9.0 → 6.0.0

package/dist/board/animation.js

@@ -1,267 +1,148 @@
 import { BOARD_BUILTIN_CAPABILITIES, DEFAULT_BOARD_RENDER_LIMITS } from "../protocol/dist/board-constants.js";
+import { BOARD_ANIMATION_CHANNELS, BoardCompositionSchema, BoardProceduralClipSchema, BoardTrackSchema } from "../protocol/dist/board-composition.js";
+import { estimateBuiltinBoardClipCost, validateBuiltinBoardClip } from "../protocol/dist/board-capability-registry.js";
+import "../protocol/dist/index.js";
 //#region src/board/animation.ts
-const ZERO_COST = {
-	particles: 0,
-	vertices: 0,
-	dynamicVertices: 0,
-	drawCalls: 0,
-	filterPasses: 0,
-	renderTexturePixels: 0,
-	textureBytes: 0,
-	bufferBytes: 0,
-	simulationSteps: 0
-};
-const DEFAULT_BOARD_LIMITS = DEFAULT_BOARD_RENDER_LIMITS;
-const BUILTIN_CAPABILITIES = BOARD_BUILTIN_CAPABILITIES;
-function numericParam(params, key, fallback) {
-	const value = params[key];
-	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+function track(input) {
+	return BoardTrackSchema.parse(input);
 }
-function builtinDefinition(capability) {
-	return {
-		...capability,
-		validate(params) {
-			const diagnostics = [];
-			if (capability.id === "effects.particles") {
-				const count = params.count;
-				const bounds = params.bounds;
-				if (!Number.isSafeInteger(count) || count < 1 || count > DEFAULT_BOARD_LIMITS.particles) diagnostics.push({
-					severity: "error",
-					code: "INVALID_PARTICLE_COUNT",
-					message: `count must be an integer between 1 and ${DEFAULT_BOARD_LIMITS.particles}`,
-					path: "params.count"
-				});
-				if (!bounds || typeof bounds !== "object" || Array.isArray(bounds)) diagnostics.push({
-					severity: "error",
-					code: "PARTICLE_BOUNDS_REQUIRED",
-					message: "particles require finite bounds",
-					path: "params.bounds"
-				});
-				else {
-					const value = bounds;
-					if (![
-						value.x,
-						value.y,
-						value.width,
-						value.height
-					].every((item) => typeof item === "number" && Number.isFinite(item)) || value.width <= 0 || value.height <= 0) diagnostics.push({
-						severity: "error",
-						code: "INVALID_PARTICLE_BOUNDS",
-						message: "particle bounds must have a positive finite size",
-						path: "params.bounds"
-					});
-				}
-			}
-			if (capability.id === "motion.path") {
-				const points = params.points;
-				if (!Array.isArray(points) || points.length < 2 || points.length > 1e4) diagnostics.push({
-					severity: "error",
-					code: "INVALID_MOTION_PATH",
-					message: "motion path must contain 2 to 10000 points",
-					path: "params.points"
-				});
-			}
-			return diagnostics;
+function proceduralClip(input) {
+	return BoardProceduralClipSchema.parse({
+		...input,
+		kindVersion: input.kindVersion ?? 1
+	});
+}
+function composition(input) {
+	return BoardCompositionSchema.parse(input);
+}
+function compileComposition(input) {
+	return composition({
+		id: input.id,
+		name: input.name,
+		timeline: {
+			duration: input.duration,
+			tracks: (input.tracks ?? []).map(track),
+			clips: (input.clips ?? []).map(proceduralClip),
+			markers: input.markers ?? []
 		},
-		getBounds(params) {
-			const bounds = params.bounds;
-			if (!bounds || typeof bounds !== "object" || Array.isArray(bounds)) return null;
-			const value = bounds;
-			return [
-				value.x,
-				value.y,
-				value.width,
-				value.height
-			].every((item) => typeof item === "number" && Number.isFinite(item)) ? value : null;
+		playback: input.playback ?? {
+			loop: false,
+			endBehavior: "hold",
+			reducedMotion: { mode: "base" }
 		},
-		estimateCost(params) {
-			switch (capability.id) {
-				case "effects.particles": {
-					const particles = Math.max(0, Math.floor(numericParam(params, "count", 0)));
-					return {
-						particles,
-						vertices: particles * 4,
-						dynamicVertices: particles * 4,
-						drawCalls: 1,
-						bufferBytes: particles * 48,
-						simulationSteps: particles
-					};
-				}
-				case "effects.trail": return {
-					vertices: 32,
-					dynamicVertices: 32,
-					drawCalls: 1,
-					bufferBytes: 1024,
-					simulationSteps: 16
-				};
-				case "effects.impact":
-				case "effects.flash": return {
-					vertices: 64,
-					drawCalls: 1
-				};
-				case "effects.color": return {
-					drawCalls: 1,
-					filterPasses: 1
-				};
-				case "draw.reveal":
-				case "draw.handwrite": return {
-					drawCalls: 1,
-					dynamicVertices: 1
-				};
-				default: return {};
-			}
-		}
-	};
+		metadata: input.metadata ?? {},
+		revision: 0
+	});
 }
-function stableHash(value) {
-	let hash = 2166136261;
-	for (let index = 0; index < value.length; index += 1) {
-		hash ^= value.charCodeAt(index);
-		hash = Math.imul(hash, 16777619);
+const clamp01 = (value) => Math.max(0, Math.min(1, value));
+function sampleEasing(easing, value) {
+	const t = clamp01(value);
+	switch (easing) {
+		case "ease-in-quad": return t * t;
+		case "ease-out-quad": return 1 - (1 - t) ** 2;
+		case "ease-in-out-quad": return t < .5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
+		case "ease-in-cubic": return t ** 3;
+		case "ease-out-cubic": return 1 - (1 - t) ** 3;
+		case "ease-in-out-cubic": return t < .5 ? 4 * t ** 3 : 1 - (-2 * t + 2) ** 3 / 2;
+		case "ease-out-quart": return 1 - (1 - t) ** 4;
+		case "ease-out-expo": return t === 1 ? 1 : 1 - 2 ** (-10 * t);
+		default: return t;
 	}
-	return (hash >>> 0).toString(36).padStart(7, "0");
-}
-function stableId(prefix, seed, path) {
-	return `${prefix}_${stableHash(`${seed}:${path}`)}`;
-}
-function assertDuration(value, field) {
-	if (!Number.isFinite(value) || value < 0) throw new TypeError(`${field} must be a finite non-negative number`);
 }
-const timeline = {
-	clip(clip) {
-		return {
-			type: "clip",
-			clip
-		};
-	},
-	parallel(...children) {
-		return {
-			type: "parallel",
-			children
-		};
-	},
-	sequence(...children) {
-		return {
-			type: "sequence",
-			children
-		};
-	},
-	stagger(each, ...children) {
-		assertDuration(each, "stagger each");
-		return {
-			type: "stagger",
-			each,
-			children
-		};
-	},
-	delay(duration, child) {
-		assertDuration(duration, "delay duration");
-		return {
-			type: "delay",
-			duration,
-			child
-		};
-	},
-	repeat(count, child) {
-		if (!Number.isSafeInteger(count) || count < 1 || count > 1e3) throw new TypeError("repeat count must be an integer between 1 and 1000");
-		return {
-			type: "repeat",
-			count,
-			child
-		};
+function interpolate(left, right, progress) {
+	if (typeof left === "number" && typeof right === "number") return left + (right - left) * progress;
+	if (left && right && typeof left === "object" && typeof right === "object" && !Array.isArray(left) && !Array.isArray(right)) {
+		const a = left;
+		const b = right;
+		const result = {};
+		for (const key of /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])) result[key] = interpolate(a[key], b[key], progress);
+		return result;
 	}
-};
-function clip(input) {
-	assertDuration(input.duration, "clip duration");
-	if (input.duration === 0) throw new TypeError("clip duration must be greater than zero");
-	return timeline.clip({
-		id: input.id,
-		kind: input.kind,
-		kindVersion: input.kindVersion ?? 1,
-		target: input.target,
-		duration: input.duration,
-		layer: input.layer ?? "content",
-		fill: input.fill ?? "none",
-		easing: input.easing ?? "linear",
-		params: input.params ?? {},
-		keyframes: input.keyframes ?? [],
-		assetRefs: input.assetRefs ?? [],
-		seed: input.seed,
-		metadata: input.metadata ?? {}
-	});
+	return progress < 1 ? left : right;
 }
-function flatten(input, offset, sequenceSeed, path) {
-	if (input.type === "clip") {
-		const clipSeed = input.clip.seed ?? `${sequenceSeed}:${path}`;
+/** Deterministically sample one validated Track without touching scene state. */
+function sampleTrack(trackValue, time) {
+	const frames = trackValue.keyframes;
+	const first = frames[0];
+	const last = frames.at(-1);
+	if (!first || !last) return null;
+	if (time < first.time) {
+		if (trackValue.fill !== "backwards" && trackValue.fill !== "both") return null;
 		return {
-			duration: input.clip.duration,
-			clips: [{
-				...input.clip,
-				id: input.clip.id ?? stableId("clip", sequenceSeed, path),
-				start: offset,
-				seed: clipSeed
-			}]
+			target: trackValue.target,
+			channel: trackValue.channel,
+			value: first.value
 		};
 	}
-	if (input.type === "delay") {
-		const nested = flatten(input.child, offset + input.duration, sequenceSeed, `${path}.child`);
+	if (time > last.time) {
+		if (trackValue.fill !== "forwards" && trackValue.fill !== "both") return null;
 		return {
-			duration: input.duration + nested.duration,
-			clips: nested.clips
+			target: trackValue.target,
+			channel: trackValue.channel,
+			value: last.value
 		};
 	}
-	if (input.type === "repeat") {
-		const clips = [];
-		let cursor = offset;
-		let total = 0;
-		for (let index = 0; index < input.count; index += 1) {
-			const nested = flatten(input.child, cursor, sequenceSeed, `${path}.${index}`);
-			clips.push(...nested.clips);
-			cursor += nested.duration;
-			total += nested.duration;
-		}
-		return {
-			duration: total,
-			clips
-		};
-	}
-	const clips = [];
-	let duration = 0;
-	for (const [index, child] of input.children.entries()) {
-		const childOffset = input.type === "sequence" ? duration : input.type === "stagger" ? input.each * index : 0;
-		const nested = flatten(child, offset + childOffset, sequenceSeed, `${path}.${index}`);
-		clips.push(...nested.clips);
-		duration = input.type === "sequence" ? duration + nested.duration : Math.max(duration, childOffset + nested.duration);
+	let low = 0;
+	let high = frames.length;
+	while (low < high) {
+		const middle = low + high >>> 1;
+		if ((frames[middle]?.time ?? Number.POSITIVE_INFINITY) <= time) low = middle + 1;
+		else high = middle;
 	}
+	const left = frames[Math.max(0, low - 1)] ?? first;
+	const right = frames[Math.min(frames.length - 1, low)] ?? last;
+	if (left === right || trackValue.interpolation === "step") return {
+		target: trackValue.target,
+		channel: trackValue.channel,
+		value: left.value
+	};
+	const span = Math.max(Number.EPSILON, right.time - left.time);
+	const progress = sampleEasing(right.easing ?? "linear", (time - left.time) / span);
 	return {
-		duration,
-		clips
+		target: trackValue.target,
+		channel: trackValue.channel,
+		value: interpolate(left.value, right.value, progress)
 	};
 }
-function compileSequence(input) {
-	const flattened = flatten(input.timeline, 0, input.seed, "root");
-	flattened.clips.sort((left, right) => left.start - right.start || left.id.localeCompare(right.id));
-	const refs = /* @__PURE__ */ new Map();
-	for (const item of flattened.clips) for (const ref of item.assetRefs) refs.set(`${ref.type}:${ref.ref}:${ref.digest ?? ""}`, ref);
+function sampleCompositionTracks(value, time) {
+	const position = Math.max(0, Math.min(value.timeline.duration, time));
+	return value.timeline.tracks.flatMap((item) => {
+		const sampled = sampleTrack(item, position);
+		return sampled ? [sampled] : [];
+	});
+}
+const ZERO_COST = {
+	particles: 0,
+	vertices: 0,
+	dynamicVertices: 0,
+	drawCalls: 0,
+	filterPasses: 0,
+	renderTexturePixels: 0,
+	textureBytes: 0,
+	bufferBytes: 0,
+	simulationSteps: 0
+};
+const DEFAULT_BOARD_LIMITS = DEFAULT_BOARD_RENDER_LIMITS;
+function builtinDefinition(capability) {
 	return {
-		sequence: {
-			id: input.id,
-			name: input.name,
-			duration: flattened.duration,
-			seed: input.seed,
-			restPose: input.restPose ?? {},
-			metadata: input.metadata ?? {}
+		...capability,
+		validate() {
+			return [];
 		},
-		clips: flattened.clips,
-		assetRefs: [...refs.values()]
+		estimateCost(params) {
+			return estimateBuiltinBoardClipCost({
+				kind: capability.id,
+				params
+			});
+		}
 	};
 }
-function addCost(target, source) {
-	for (const key of Object.keys(target)) target[key] += source[key] ?? 0;
-}
 var BoardExtensionRegistry = class {
 	#extensions = /* @__PURE__ */ new Map();
 	#presets = /* @__PURE__ */ new Map();
+	constructor() {
+		for (const capability of BOARD_BUILTIN_CAPABILITIES) this.register(builtinDefinition(capability));
+	}
 	register(definition) {
 		const key = `${definition.kind}:${definition.id}@${definition.version}`;
 		const target = definition.kind === "preset" ? this.#presets : this.#extensions;
@@ -270,9 +151,15 @@ var BoardExtensionRegistry = class {
 		return this;
 	}
 	capabilities() {
-		const extensions = [...this.#extensions.values()].map(({ validate: _validate, getBounds: _bounds, getAssetRefs: _refs, estimateCost: _cost, ...definition }) => definition);
-		const presets = [...this.#presets.values()].map(({ compile: _compile, ...definition }) => definition);
-		return [...extensions, ...presets];
+		return [...this.#extensions.values(), ...this.#presets.values()].map((definition) => ({
+			kind: definition.kind,
+			id: definition.id,
+			version: definition.version,
+			...definition.digest ? { digest: definition.digest } : {},
+			...definition.renderers ? { renderers: definition.renderers } : {},
+			...definition.fallbackId ? { fallbackId: definition.fallbackId } : {},
+			...definition.schema ? { schema: definition.schema } : {}
+		}));
 	}
 	compilePreset(id, version, params) {
 		const preset = this.#presets.get(`preset:${id}@${version}`);
@@ -280,74 +167,72 @@ var BoardExtensionRegistry = class {
 		return preset.compile(params);
 	}
 	validate(input) {
+		const parsed = BoardCompositionSchema.safeParse(input.composition);
+		if (!parsed.success) return {
+			valid: false,
+			diagnostics: parsed.error.issues.map((issue) => ({
+				severity: "error",
+				code: "INVALID_COMPOSITION",
+				message: issue.message,
+				path: issue.path.join(".")
+			})),
+			peakCost: { ...ZERO_COST }
+		};
 		const diagnostics = [];
+		const composition = parsed.data;
+		const cost = { ...ZERO_COST };
 		const events = [];
-		const profile = input.profile ?? "high";
-		const persistentCost = { ...ZERO_COST };
-		for (const [index, effect] of (input.effects ?? []).entries()) {
-			const definition = this.#extensions.get(`effect:${effect.kind}@${effect.kindVersion}`);
-			if (!definition) {
-				diagnostics.push({
-					severity: "warning",
-					code: "UNKNOWN_EFFECT",
-					message: `No renderer is registered for ${effect.kind}@${effect.kindVersion}`,
-					path: `effects.${index}`
-				});
-				continue;
-			}
-			diagnostics.push(...definition.validate?.(effect.params) ?? []);
-			addCost(persistentCost, definition.estimateCost(effect.params, profile));
-		}
-		for (const [index, clip] of input.clips.entries()) {
+		for (const clip of composition.timeline.clips) {
 			const definition = this.#extensions.get(`clip:${clip.kind}@${clip.kindVersion}`);
 			if (!definition) {
 				diagnostics.push({
 					severity: "warning",
 					code: "UNKNOWN_CLIP",
-					message: `No renderer is registered for ${clip.kind}@${clip.kindVersion}`,
-					path: `clips.${index}`
+					message: `No renderer is registered for ${clip.kind}@${clip.kindVersion}`
 				});
 				continue;
 			}
+			diagnostics.push(...validateBuiltinBoardClip(clip, `composition.timeline.clips.${clip.id}`));
 			diagnostics.push(...definition.validate?.(clip.params) ?? []);
-			const cost = { ...ZERO_COST };
-			addCost(cost, definition.estimateCost(clip.params, profile));
+			const estimate = definition.estimateCost(clip.params, input.profile ?? "high");
+			const clipCost = { ...ZERO_COST };
+			for (const key of Object.keys(clipCost)) clipCost[key] = estimate[key] ?? 0;
 			events.push({
 				at: clip.start,
 				direction: 1,
-				cost
-			}, {
+				cost: clipCost
+			});
+			events.push({
 				at: clip.start + clip.duration,
 				direction: -1,
-				cost
+				cost: clipCost
 			});
 		}
 		events.sort((left, right) => left.at - right.at || left.direction - right.direction);
-		const current = { ...persistentCost };
-		const peak = { ...persistentCost };
-		for (const event of events) for (const key of Object.keys(current)) {
-			current[key] += event.cost[key] * event.direction;
-			peak[key] = Math.max(peak[key], current[key]);
+		const active = { ...ZERO_COST };
+		for (const event of events) for (const key of Object.keys(active)) {
+			active[key] += event.cost[key] * event.direction;
+			cost[key] = Math.max(cost[key], active[key]);
 		}
+		for (const effect of input.effects ?? []) if (effect.kind === "effects.pulse" || effect.kind === "effects.float") cost.drawCalls += 1;
 		const limits = input.limits ?? DEFAULT_BOARD_LIMITS;
-		for (const key of Object.keys(limits)) if (peak[key] > limits[key]) diagnostics.push({
+		for (const key of Object.keys(cost)) if (cost[key] > limits[key]) diagnostics.push({
 			severity: "warning",
 			code: "RENDER_BUDGET_EXCEEDED",
-			message: `${key} peaks at ${peak[key]}, above ${limits[key]}`,
+			message: `${key} peaks at ${cost[key]}, above ${limits[key]}`,
 			path: key,
 			adaptation: { quality: "lower" }
 		});
 		return {
 			valid: !diagnostics.some((item) => item.severity === "error"),
 			diagnostics,
-			peakCost: peak
+			peakCost: cost
 		};
 	}
 };
-function createBoardExtensionRegistry(input = {}) {
-	const registry = new BoardExtensionRegistry();
-	if (input.builtins !== false) for (const capability of BUILTIN_CAPABILITIES) registry.register(builtinDefinition(capability));
-	return registry;
+function createBoardExtensionRegistry() {
+	return new BoardExtensionRegistry();
 }
+const BOARD_CHANNELS = BOARD_ANIMATION_CHANNELS;
 //#endregion
-export { BoardExtensionRegistry, DEFAULT_BOARD_LIMITS, clip, compileSequence, createBoardExtensionRegistry, timeline };
+export { BOARD_CHANNELS, BoardExtensionRegistry, DEFAULT_BOARD_LIMITS, compileComposition, composition, createBoardExtensionRegistry, proceduralClip, sampleCompositionTracks, sampleEasing, sampleTrack, track };

package/dist/board/codec.js

@@ -1,7 +1,7 @@
 import { BOARD_DOCUMENT_KIND, InvalidBoardFileError, isBoardPath, parseBoardManifest, serializeBoardManifest } from "../protocol/dist/board.js";
 import { BoardAppearanceSchema, BoardFileSnapshotSchema, BoardTaskSnapshotSchema, UNKNOWN_BOARD_ITEM_TYPE, parseBoardDocument } from "../protocol/dist/board-document.js";
-import { TEXT_FONT_SIZE, clampBoardTextFontSize } from "./core/text-metrics.js";
 import "../protocol/dist/index.js";
+import { TEXT_FONT_SIZE, clampBoardTextFontSize } from "./core/text-metrics.js";
 //#region src/board/codec.ts
 const DEFAULT_BOARD_APPEARANCE = BoardAppearanceSchema.parse({
 	theme: "clean",

package/dist/board/export/index.d.ts

@@ -23,6 +23,12 @@ type BoardExportOptions = {
   textures?: Map<string, Texture>;
   /** Preview-key strategy supplied by the host; defaults to still images only. */
   assetKey?: (item: BoardItem) => string | null;
+  backgroundImage?: {
+    texture: Texture;
+    fit: "cover" | "contain" | "repeat";
+    position: "center" | "top" | "bottom" | "left" | "right";
+    opacity: number;
+  };
   maxEdge?: number;
   maxPixels?: number;
 };

package/dist/board/export/index.js

@@ -1,12 +1,14 @@
 import { normalizeBoardDocument, planBoardExport } from "../core/export-plan.js";
+import { parseBoardCssColor } from "../render/css-color.js";
 import { defaultBoardPalette } from "../render/palette.js";
 import { createBoardExportScene } from "./scene.js";
 import { Rectangle } from "pixi.js";
 //#region src/board/export/index.ts
-function resolveBackground(background, palette) {
+function resolveBackground(background, palette, document) {
 	if (background === "transparent") return null;
 	if (typeof background === "number") return background;
-	return palette.bg;
+	const declared = document.appearance.background.color;
+	return declared ? parseBoardCssColor(declared) ?? palette.bg : palette.bg;
 }
 /**
 * Capture a board region as a canvas.
@@ -42,7 +44,8 @@ function renderBoardExport(renderer, input, options = {}) {
 		colors: options.colors,
 		textures: options.textures,
 		assetKey: options.assetKey,
-		background: resolveBackground(options.background, palette)
+		background: resolveBackground(options.background, palette, document),
+		backgroundImage: options.backgroundImage
 	});
 	try {
 		const canvas = renderer.extract.canvas({

package/dist/board/export/scene.d.ts

@@ -25,6 +25,12 @@ type BoardExportSceneInput = {
   assetKey?: (item: BoardItem) => string | null;
   /** Opaque paper behind the content, or null for transparency. */
   background?: number | null;
+  backgroundImage?: {
+    texture: Texture;
+    fit: "cover" | "contain" | "repeat";
+    position: "center" | "top" | "bottom" | "left" | "right";
+    opacity: number;
+  };
 };
 type BoardExportScene = {
   /** Root to hand to the renderer; already positioned and scaled. */

package/dist/board/export/scene.js

@@ -3,7 +3,7 @@ import { buildFallbackShapeColors } from "../core/palette.js";
 import { createConnectionLayer } from "../render/connection-layer.js";
 import { defaultBoardPalette } from "../render/palette.js";
 import { getBoardCardRenderer } from "../render/renderers/board-renderer-registry.js";
-import { Container, Graphics } from "pixi.js";
+import { Container, Graphics, Sprite, TilingSprite } from "pixi.js";
 //#region src/board/export/scene.ts
 /**
 * Render context for an export.
@@ -45,10 +45,34 @@ function buildContext(input) {
 function createBoardExportScene(input) {
 	const { context, missing } = buildContext(input);
 	const root = new Container({ label: "board-export-root" });
-	if (input.background != null) root.addChild(new Graphics().rect(0, 0, input.world.width * input.scale, input.world.height * input.scale).fill({
+	const outputWidth = input.world.width * input.scale;
+	const outputHeight = input.world.height * input.scale;
+	if (input.background != null) root.addChild(new Graphics().rect(0, 0, outputWidth, outputHeight).fill({
 		color: input.background,
 		alpha: 1
 	}));
+	if (input.backgroundImage) {
+		const { texture, fit, position, opacity } = input.backgroundImage;
+		if (fit === "repeat") root.addChild(new TilingSprite({
+			texture,
+			width: outputWidth,
+			height: outputHeight,
+			alpha: opacity
+		}));
+		else {
+			const sprite = new Sprite({
+				texture,
+				alpha: opacity
+			});
+			const scale = fit === "cover" ? Math.max(outputWidth / texture.width, outputHeight / texture.height) : Math.min(outputWidth / texture.width, outputHeight / texture.height);
+			sprite.width = texture.width * scale;
+			sprite.height = texture.height * scale;
+			const x = position === "left" ? 0 : position === "right" ? outputWidth - sprite.width : (outputWidth - sprite.width) / 2;
+			const y = position === "top" ? 0 : position === "bottom" ? outputHeight - sprite.height : (outputHeight - sprite.height) / 2;
+			sprite.position.set(x, y);
+			root.addChild(sprite);
+		}
+	}
 	const world = new Container({
 		isRenderGroup: true,
 		label: "board-export-world"