pixel-daylight-switch-gsvegetable 3.0.0 → 3.0.1

package/README.ja.md

@@ -129,7 +129,17 @@ Manifest v1 はシーン ID、作者・ライセンス、ピクセルキャン
 - [Manifest v1 JSON Schema](schemas/scene-manifest.v1.schema.json)
 - [Sakura Evening サンプル](examples/scenes/sakura-evening.json)
 
-v1 は外部画像/Sprite、レイヤー式 Tile Map、独自アニメーショントラックにはまだ対応していません。これらは任意コードの実行を許可せず、将来の独立した Schema 拡張として追加します。5 つの組み込みシーンは従来の描画・アニメーション実装を維持します。
+### Manifest v2：レイヤー付きピクセルワールド（v3.0.1）
+
+3.0.1 では Manifest v1 を変更せずに v2 を追加しました。v2 は最大 24 個の再利用可能なピクセルアセットと、最大 16 個の順序付きレイヤーに対応します。レイヤーはシーン座標に配置でき、drift または bob の宣言型モーショントラックで横・縦方向に動かせます。重ねるアセット内の . は透明として扱い、それ以外の文字は昼夜パレットで着色されます。
+
+- [Manifest v2 JSON Schema](schemas/scene-manifest.v2.schema.json)
+- [Floating Island レイヤーサンプル](examples/scenes/floating-island.v2.json)
+- [シーンプラグイン開発ガイド](SCENE_PLUGINS.md)
+
+v2 のアセットは文字ベースのピクセルマップです。PNG/JPEG の外部ダウンロードには対応しません。これによりピクセル表現と昼夜の色変化を一貫させ、外部画像の CORS や任意コード実行を避けます。
+
+5 つの組み込みシーンは従来の描画・アニメーション実装を維持します。
 
 ## 設定属性
 

package/README.md

@@ -128,7 +128,27 @@ registerScene(sakura);
 PixelDaylightSwitch.mount(document.querySelector('[data-ld-part="toggle-daylight"]'));
 ```
 
-### Manifest v1
+### Manifest v2 — layered pixel worlds (v3.0.1)
+
+Version 3.0.1 extends the community scene format without changing Manifest v1. V2 scenes can define up to 24 reusable pixel-matrix assets and up to 16 ordered layers. A layer places an asset at integer scene coordinates and can optionally animate with a deterministic drift or bob track along either axis. The dot (.) is transparent in overlay assets; all other symbols are color-mapped by the scene palettes.
+
+```js
+import PixelDaylightSwitch, { registerScene } from 'pixel-daylight-switch-gsvegetable';
+import island from './floating-island.v2.json';
+
+registerScene(island);
+const root = document.querySelector('[data-ld-part="toggle-daylight"]');
+root.dataset.scene = island.id;
+PixelDaylightSwitch.mount(root);
+```
+
+- [Manifest v2 JSON Schema](schemas/scene-manifest.v2.schema.json)
+- [Floating Island layered example](examples/scenes/floating-island.v2.json)
+- [Full scene authoring guide](SCENE_PLUGINS.md)
+
+V2 assets are native pixel matrices, not downloaded PNG/JPEG files. This keeps the scene pipeline deterministic and avoids remote asset/CORS dependencies or executable plugin code.
+
+## Manifest v1
 
 A manifest contains a fixed-size character pixel map, named color palettes and a 24-hour palette timeline. The renderer interpolates colors between timeline stops while keeping the same scene geometry.
 

package/README.zh-CN.md

@@ -129,7 +129,17 @@ Manifest v1 包含场景 ID、作者与许可证、像素画布、字符像素
 - [Manifest v1 JSON Schema](schemas/scene-manifest.v1.schema.json)
 - [樱花黄昏示例](examples/scenes/sakura-evening.json)
 
-v1 暂不支持外部图片/Sprite、分层 Tile Map 和自定义动画轨道；这些能力会通过后续独立版本的 Schema 扩展，不会开放任意代码执行。五个内置场景仍保留原有绘制与动态逻辑。
+### Manifest v2：分层像素世界（v3.0.1）
+
+3.0.1 在不改变 Manifest v1 的前提下增加了 v2。v2 支持最多 24 个可复用像素素材、最多 16 个按顺序合成的图层。图层可以指定场景坐标，并使用 drift 或 bob 声明式运动轨道沿水平或垂直方向移动。叠加素材中的点号 . 表示透明，其余字符由昼夜色板统一着色。
+
+- [Manifest v2 JSON Schema](schemas/scene-manifest.v2.schema.json)
+- [Floating Island 分层场景示例](examples/scenes/floating-island.v2.json)
+- [完整场景插件开发指南](SCENE_PLUGINS.md)
+
+当前 v2 素材采用原生字符像素矩阵，而不是远程 PNG/JPEG 图片；这样可以保持像素边缘清晰、昼夜调色一致，也不需要额外的跨域图片加载或执行第三方代码。
+
+五个内置场景仍保留原有绘制与动态逻辑。
 
 ## 配置参数
 

package/SCENE_PLUGINS.md

@@ -1,6 +1,6 @@
 # Scene Plugin Guide
 
-Pixel Daylight Switch 3.0.0 introduces a declarative community-scene format. A scene is JSON data, not an executable JavaScript plugin. The renderer validates the manifest and draws the resulting pixel world through the existing refractive-glass pipeline.
+Pixel Daylight Switch 3.0.0 introduced a declarative community-scene format. A scene is JSON data, not an executable JavaScript plugin. The renderer validates the manifest and draws the resulting pixel world through the existing refractive-glass pipeline.
 
 ## Two ways to create a scene
 
@@ -50,7 +50,7 @@ The one-line `embed.js` loader loads the registry before the renderer, but it do
 
 Required fields:
 
-- `schemaVersion`: currently `1`.
+- `schemaVersion`: `1` for the original single-matrix format or `2` for layered pixel assets and motion.
 - `id`: unique lowercase ID, 3–64 characters. Built-in scene IDs are reserved.
 - `name`, `author`, `license`: scene metadata.
 - `canvas`: width 1–192 and height 1–112.
@@ -62,6 +62,22 @@ Every symbol used in `pixels` must have a color in every palette. The renderer i
 
 The authoritative machine-readable contract is [schemas/scene-manifest.v1.schema.json](schemas/scene-manifest.v1.schema.json). A complete sample is [examples/scenes/sakura-evening.json](examples/scenes/sakura-evening.json).
 
+## Layered scenes and pixel assets (Manifest v2)
+
+Version 3.0.1 adds reusable pixel-art assets, compositing layers and deterministic motion tracks. Manifest v1 remains supported without changes; use `schemaVersion: 2` to opt in.
+
+A v2 manifest keeps the base `canvas`, `pixels`, `palettes` and `timeCycle`, and adds:
+
+- `assets`: up to 24 named pixel matrices (each up to 192 × 112).
+- `layers`: 1–16 ordered placements that reference an asset and specify integer `x` / `y` coordinates.
+- `animation`: optional `drift` or `bob` motion on either axis, with bounded speed, distance and phase.
+
+The dot character (`.`) is transparent when an asset is composited as a layer. All other characters are palette symbols, so every palette must define colors for symbols used by the base matrix and every asset. Layers are drawn in array order; later layers appear above earlier ones. Motion is deterministic and uses the scene's animation clock; it does not execute plugin code.
+
+Example: [Floating Island v2](examples/scenes/floating-island.v2.json). The v2 contract is [schemas/scene-manifest.v2.schema.json](schemas/scene-manifest.v2.schema.json); the original v1 contract remains at [schemas/scene-manifest.v1.schema.json](schemas/scene-manifest.v1.schema.json).
+
+The current asset format is deliberately pixel-matrix based. Arbitrary PNG/JPEG downloads and executable animation callbacks are not part of v3.0.1; this keeps rendering crisp, portable, CSP-friendly and safe for community contributions.
+
 ## API
 
 - `registerScene(manifest)`: validate, snapshot and register a scene; returns an unregister function.
@@ -73,6 +89,6 @@ Registration rejects duplicate IDs, built-in IDs, malformed dimensions, invalid
 
 ## Scope and safety
 
-Manifest v1 supports palette-driven pixel maps. It intentionally does not execute plugin JavaScript, evaluate expressions, or load arbitrary code. External image/sprite assets, layered tile maps and custom animation tracks are not part of v1; they should be introduced through a separately versioned schema extension with explicit asset limits and lifecycle rules.
+Manifest v1 supports palette-driven pixel maps; Manifest v2 adds bounded pixel-matrix assets, ordered layers and declarative drift/bob tracks. Neither version executes plugin JavaScript, evaluates expressions, loads arbitrary code or downloads external images. Raster image imports and tile-atlas tooling are outside the v3.0.1 scope.
 
 All five built-in scenes continue to use their original hand-authored painters and scene-specific live behavior. Community scenes use the data-driven renderer and do not replace or mutate built-in scene definitions.

package/app.js

@@ -931,6 +931,7 @@ function mount(root) {
     Object.keys(palette).forEach((symbol) => { colors[symbol.charCodeAt(0)] = parsePluginColor(palette[symbol]); });
     return [name, colors];
   })) : null;
+  let pluginAnimClock = 0;
   const renderPluginWorld = (hour) => {
     const stops = pluginScene.timeCycle;
     let left = stops[0]; let right = stops[stops.length - 1]; let sampleHour = hour;
@@ -945,14 +946,43 @@ function mount(root) {
     const aPalette = pluginPaletteRgb[left.palette];
     const bPalette = pluginPaletteRgb[right.palette];
     const width = pluginScene.canvas.width; const height = pluginScene.canvas.height;
+    let scenePixels = pluginScene.pixels;
+    if (pluginScene.schemaVersion === 2 && Array.isArray(pluginScene.layers)) {
+      const composed = pluginScene.pixels.map(row => row.split(''));
+      for (const layer of pluginScene.layers) {
+        const asset = pluginScene.assets[layer.asset];
+        const motion = layer.animation;
+        let dx = 0, dy = 0;
+        if (motion) {
+          const phase = pluginAnimClock * motion.speed + (motion.phase || 0);
+          const wave = motion.type === 'drift' ? (2 / Math.PI) * Math.asin(Math.sin(phase)) : Math.sin(phase);
+          const offset = wave * motion.distance;
+          if (motion.axis === 'x') dx = Math.round(offset);
+          else dy = Math.round(offset);
+        }
+        const originX = layer.x + dx, originY = layer.y + dy;
+        for (let sy = 0; sy < asset.height; sy++) {
+          const targetY = originY + sy;
+          if (targetY < 0 || targetY >= height) continue;
+          const row = asset.pixels[sy];
+          for (let sx = 0; sx < asset.width; sx++) {
+            const targetX = originX + sx;
+            if (targetX < 0 || targetX >= width) continue;
+            const symbol = row[sx];
+            if (symbol !== '.') composed[targetY][targetX] = symbol;
+          }
+        }
+      }
+      scenePixels = composed.map(row => row.join(''));
+    }
     const scale = Math.min(bw / width, bh / height);
     const drawW = Math.max(1, Math.round(width * scale)); const drawH = Math.max(1, Math.round(height * scale));
     const offsetX = Math.floor((bw - drawW) / 2); const offsetY = Math.floor((bh - drawH) / 2);
-    const background = pluginScene.pixels[0].charCodeAt(0);
+    const background = scenePixels[0].charCodeAt(0);
     for (let py = 0; py < bh; py++) {
       const insideY = py >= offsetY && py < offsetY + drawH;
       const sy = insideY ? clamp(Math.floor(((py - offsetY) / drawH) * height), 0, height - 1) : 0;
-      const row = pluginScene.pixels[sy];
+      const row = scenePixels[sy];
       for (let px = 0; px < bw; px++) {
         const inside = insideY && px >= offsetX && px < offsetX + drawW;
         const sx = inside ? clamp(Math.floor(((px - offsetX) / drawW) * width), 0, width - 1) : 0;
@@ -1083,7 +1113,7 @@ function mount(root) {
   const pickKeys = (h) => { for (let i = 0; i < KEYS.length - 1; i++) { if (h >= KEYS[i][0] && h < KEYS[i + 1][0]) { keyA = i; keyB = i + 1; keyP = clamp(((h - KEYS[i][0]) / (KEYS[i + 1][0] - KEYS[i][0]) - 0.32) / 0.36); return; } } keyA = 0; keyB = 1; keyP = 0; };
   const renderWorld = (clock, dt, hurry) => {
     const h = hourOf(clock);
-    if (pluginScene) { renderPluginWorld(h); return; }
+    if (pluginScene) { if (!calm) pluginAnimClock += dt; renderPluginWorld(h); return; }
     if (!calm) anim += dt; matBuf.set(baseBuf); varBuf.fill(0); emitList.length = 0;
     for (const c of sources) { c.w = 0; c.x = 0; c.y = 0; }
     lampFlick = calm ? 1 : 0.95 + 0.05 * Math.sin(anim * 13) * Math.sin(anim * 5.3);

package/examples/scenes/floating-island.v2.json

@@ -0,0 +1,152 @@
+{
+  "schemaVersion": 2,
+  "id": "floating-island",
+  "name": "Floating Island",
+  "author": "Pixel Daylight Switch",
+  "license": "CC0-1.0",
+  "canvas": {
+    "width": 24,
+    "height": 12
+  },
+  "pixels": [
+    "........................",
+    "........................",
+    "........................",
+    "........................",
+    "........................",
+    "........................",
+    "........................",
+    "........................",
+    "........................",
+    "........................",
+    "........................",
+    "........................"
+  ],
+  "palettes": {
+    "day": {
+      ".": "#8ed5f4",
+      "g": "#74b66d",
+      "t": "#79543f",
+      "l": "#f8d77a",
+      "c": "#ffffff"
+    },
+    "dusk": {
+      ".": "#e99a91",
+      "g": "#627e69",
+      "t": "#5b4653",
+      "l": "#f6bb86",
+      "c": "#f4c6d0"
+    },
+    "night": {
+      ".": "#171d3b",
+      "g": "#304b4a",
+      "t": "#302c43",
+      "l": "#f1d28a",
+      "c": "#a8b7e8"
+    }
+  },
+  "timeCycle": [
+    {
+      "at": 0,
+      "palette": "night"
+    },
+    {
+      "at": 6,
+      "palette": "night"
+    },
+    {
+      "at": 8,
+      "palette": "day"
+    },
+    {
+      "at": 17,
+      "palette": "day"
+    },
+    {
+      "at": 19,
+      "palette": "dusk"
+    },
+    {
+      "at": 21,
+      "palette": "night"
+    },
+    {
+      "at": 24,
+      "palette": "night"
+    }
+  ],
+  "assets": {
+    "island": {
+      "width": 14,
+      "height": 4,
+      "pixels": [
+        "......gg......",
+        "....gggggg....",
+        "..gggggggggg..",
+        "gggggggggggggg"
+      ]
+    },
+    "tree": {
+      "width": 5,
+      "height": 7,
+      "pixels": [
+        "..g..",
+        ".ggg.",
+        "ggggg",
+        "..t..",
+        "..t..",
+        "..t..",
+        "..t.."
+      ]
+    },
+    "cloud": {
+      "width": 8,
+      "height": 3,
+      "pixels": [
+        "..cccc..",
+        ".cccccc.",
+        "cccccccc"
+      ]
+    }
+  },
+  "layers": [
+    {
+      "id": "island",
+      "asset": "island",
+      "x": 5,
+      "y": 7
+    },
+    {
+      "id": "tree",
+      "asset": "tree",
+      "x": 8,
+      "y": 0
+    },
+    {
+      "id": "cloud-left",
+      "asset": "cloud",
+      "x": -3,
+      "y": 2,
+      "animation": {
+        "type": "drift",
+        "axis": "x",
+        "speed": 0.12,
+        "distance": 4,
+        "phase": 0
+      }
+    },
+    {
+      "id": "cloud-right",
+      "asset": "cloud",
+      "x": 17,
+      "y": 4,
+      "animation": {
+        "type": "bob",
+        "axis": "y",
+        "speed": 0.18,
+        "distance": 2,
+        "phase": 1.4
+      }
+    }
+  ]
+}

package/index.d.ts

@@ -1,38 +1,52 @@
 export interface ScenePalette {
   [symbol: string]: `#${string}`;
 }
-
-export interface SceneTimeStop {
-  /** Local scene time in hours, from 0 through 24. */
-  at: number;
-  /** Key in SceneManifest.palettes. */
-  palette: string;
+export interface SceneTimeStop { at: number; palette: string; }
+export interface ScenePixelAsset {
+  width: number;
+  height: number;
+  /** One printable-ASCII character per pixel. A dot is transparent when used as a layer. */
+  pixels: string[];
+}
+export interface SceneLayerAnimation {
+  /** drift and bob are deterministic sinusoidal motion tracks. */
+  type: 'drift' | 'bob';
+  axis: 'x' | 'y';
+  /** Angular speed in radians per second, from 0 to 4. */
+  speed: number;
+  /** Motion amplitude in scene pixels, from 1 to 64. */
+  distance: number;
+  /** Optional phase in radians, from 0 to 2π. */
+  phase?: number;
+}
+export interface SceneLayer {
+  id: string;
+  asset: string;
+  x: number;
+  y: number;
+  animation?: SceneLayerAnimation;
 }
-
-export interface SceneManifest {
-  schemaVersion: 1;
-  /** Unique lowercase community scene identifier (3-64 characters). */
+export interface SceneManifestBase {
   id: string;
   name: string;
   author: string;
-  /** SPDX identifier or a clearly stated license label. */
   license: string;
   canvas: { width: number; height: number };
-  /** One printable-ASCII character per pixel; rows match canvas dimensions. */
   pixels: string[];
-  /** Each palette maps every used pixel symbol to a #RGB or #RRGGBB color. */
   palettes: Record<string, ScenePalette>;
-  /** Strictly increasing palette stops; must begin at 0 and end at 24. */
   timeCycle: SceneTimeStop[];
 }
-
-export interface SceneValidationResult {
-  valid: boolean;
-  errors: string[];
+/** Manifest v1 preserves the original single pixel-matrix format. */
+export interface SceneManifestV1 extends SceneManifestBase { schemaVersion: 1; }
+/** Manifest v2 adds reusable pixel assets, compositing layers and declarative motion. */
+export interface SceneManifestV2 extends SceneManifestBase {
+  schemaVersion: 2;
+  assets: Record<string, ScenePixelAsset>;
+  layers: SceneLayer[];
 }
-
+export type SceneManifest = SceneManifestV1 | SceneManifestV2;
+export interface SceneValidationResult { valid: boolean; errors: string[]; }
 export type UnregisterScene = () => boolean;
-
 export interface PixelDaylightSwitchAPI {
   mount(root: Element | null): (() => void) | null;
   unmount(root: Element | null): void;
@@ -41,7 +55,6 @@ export interface PixelDaylightSwitchAPI {
   getScene(id: string): SceneManifest | null;
   listScenes(): SceneManifest[];
 }
-
 declare const PixelDaylightSwitch: PixelDaylightSwitchAPI;
 export declare const mount: PixelDaylightSwitchAPI['mount'];
 export declare const unmount: PixelDaylightSwitchAPI['unmount'];

package/llms.txt

@@ -109,3 +109,14 @@ Invalid values fall back to defaults; documented numeric ranges are clamped.
 - Scene registration is data-only; arbitrary plugin JavaScript is not executed.
 - Browser script order: scene-plugin.js, register the manifest, then app.js. The one-line embed loader loads the registry before the renderer.
 - Existing built-in scenes and their custom live animation code remain unchanged.
+
+
+## Scene Manifest v2 (v3.0.1)
+
+- Manifest v1 remains supported and its schema is unchanged.
+- Manifest v2 adds up to 24 reusable pixel-matrix assets and up to 16 ordered layers.
+- Layers reference named assets and integer x/y positions; '.' is transparent in overlay assets.
+- Optional deterministic motion tracks: drift or bob, on x or y, bounded speed/distance/phase.
+- Every symbol across the base matrix and assets must be defined in every palette.
+- Schema: schemas/scene-manifest.v2.schema.json. Example: examples/scenes/floating-island.v2.json.
+- No arbitrary remote image loading, eval, or executable plugin callbacks.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pixel-daylight-switch-gsvegetable",
-  "version": "3.0.0",
-  "description": "A draggable pixel-art day/night switch with a community-extensible scene plugin system.",
+  "version": "3.0.1",
+  "description": "A draggable pixel-art day/night switch with layered, animated community scenes.",
   "keywords": [
     "pixel-art",
     "day-night",

package/scene-plugin.js

@@ -8,7 +8,7 @@
 })(typeof globalThis !== 'undefined' ? globalThis : this, function () {
   'use strict';
   const registry = new Map();
-  const MAX_WIDTH = 192, MAX_HEIGHT = 112, MAX_PALETTES = 8, MAX_SYMBOLS = 64, MAX_TIME_STOPS = 48;
+  const MAX_WIDTH = 192, MAX_HEIGHT = 112, MAX_PALETTES = 8, MAX_SYMBOLS = 64, MAX_TIME_STOPS = 48, MAX_ASSETS = 24, MAX_LAYERS = 16, MAX_TOTAL_CELLS = 430080;
   const ID_RE = /^[a-z0-9][a-z0-9._-]{1,62}[a-z0-9]$/;
   const COLOR_RE = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
   const SYMBOL_RE = /^[\x20-\x7E]$/;
@@ -24,8 +24,10 @@
   function validateScene(input) {
     const errors = [];
     if (!isPlainObject(input)) return { valid:false, errors:['Scene manifest must be a plain object.'] };
-    unknownKeys(input, new Set(['schemaVersion','id','name','author','license','canvas','pixels','palettes','timeCycle']), 'manifest', errors);
-    if (input.schemaVersion !== 1) errors.push('schemaVersion must be 1.');
+    unknownKeys(input, new Set(['schemaVersion','id','name','author','license','canvas','pixels','palettes','timeCycle','assets','layers']), 'manifest', errors);
+    if (input.schemaVersion !== 1 && input.schemaVersion !== 2) errors.push('schemaVersion must be 1 or 2.');
+    if (input.schemaVersion === 1 && (input.assets !== undefined || input.layers !== undefined)) errors.push('assets and layers require schemaVersion 2.');
+    if (input.schemaVersion !== 1 && input.schemaVersion !== 2) errors.push('schemaVersion must be 1 or 2.');
     if (typeof input.id !== 'string' || !ID_RE.test(input.id)) errors.push('id must be 3-64 lowercase letters, numbers, dots, underscores or hyphens.');
     if (BUILT_INS.has(input.id)) errors.push('Built-in scene IDs are reserved.');
     if (typeof input.name !== 'string' || !input.name.trim() || input.name.length > 80) errors.push('name must be a non-empty string of at most 80 characters.');
@@ -65,6 +67,49 @@
         }
       });
     }
+    const assets = input.assets;
+    if (input.schemaVersion === 2) {
+      if (!isPlainObject(assets) || Object.keys(assets).length < 1) errors.push('schemaVersion 2 requires at least one named pixel asset.');
+      else {
+        const names = Object.keys(assets);
+        if (names.length > MAX_ASSETS) errors.push('assets may contain at most 24 pixel assets.');
+        names.forEach(name => {
+          const asset = assets[name];
+          if (!/^[a-z0-9][a-z0-9._-]{0,47}$/.test(name)) errors.push('Asset names must be lowercase identifiers.');
+          if (!isPlainObject(asset)) { errors.push('Asset "' + name + '" must be an object.'); return; }
+          unknownKeys(asset, new Set(['width','height','pixels']), 'assets.' + name, errors);
+          if (!Number.isInteger(asset.width) || asset.width < 1 || asset.width > MAX_WIDTH) errors.push('Asset "' + name + '" width must be 1-192.');
+          if (!Number.isInteger(asset.height) || asset.height < 1 || asset.height > MAX_HEIGHT) errors.push('Asset "' + name + '" height must be 1-112.');
+          if (!Array.isArray(asset.pixels) || asset.pixels.length !== asset.height) errors.push('Asset "' + name + '" pixels must match its height.');
+          else asset.pixels.forEach((row,index) => {
+            if (typeof row !== 'string' || row.length !== asset.width || !Array.from(row).every(symbol => SYMBOL_RE.test(symbol))) errors.push('Asset "' + name + '" row ' + index + ' must be printable ASCII and match its width.');
+          });
+        });
+      }
+      if (!Array.isArray(input.layers) || input.layers.length < 1 || input.layers.length > MAX_LAYERS) errors.push('layers must contain 1-16 layer definitions.');
+      else input.layers.forEach((layer,index) => {
+        if (!isPlainObject(layer)) { errors.push('layers[' + index + '] must be an object.'); return; }
+        unknownKeys(layer, new Set(['id','asset','x','y','animation']), 'layers[' + index + ']', errors);
+        if (typeof layer.id !== 'string' || !/^[a-z0-9][a-z0-9._-]{0,47}$/.test(layer.id)) errors.push('layers[' + index + '].id must be a lowercase identifier.');
+        if (!isPlainObject(assets) || typeof layer.asset !== 'string' || !Object.prototype.hasOwnProperty.call(assets,layer.asset)) errors.push('layers[' + index + '] references an unknown asset.');
+        if (!Number.isInteger(layer.x) || layer.x < -MAX_WIDTH || layer.x > MAX_WIDTH) errors.push('layers[' + index + '].x must be an integer from -192 to 192.');
+        if (!Number.isInteger(layer.y) || layer.y < -MAX_HEIGHT || layer.y > MAX_HEIGHT) errors.push('layers[' + index + '].y must be an integer from -112 to 112.');
+        if (layer.animation !== undefined) {
+          const animation = layer.animation;
+          if (!isPlainObject(animation)) errors.push('layers[' + index + '].animation must be an object.');
+          else {
+            unknownKeys(animation,new Set(['type','axis','speed','distance','phase']),'layers[' + index + '].animation',errors);
+            if (animation.type !== 'drift' && animation.type !== 'bob') errors.push('Animation type must be drift or bob.');
+            if (animation.axis !== 'x' && animation.axis !== 'y') errors.push('Animation axis must be x or y.');
+            if (!Number.isFinite(animation.speed) || animation.speed < 0 || animation.speed > 4) errors.push('Animation speed must be between 0 and 4.');
+            if (!Number.isInteger(animation.distance) || animation.distance < 1 || animation.distance > 64) errors.push('Animation distance must be an integer from 1 to 64.');
+            if (animation.phase !== undefined && (!Number.isFinite(animation.phase) || animation.phase < 0 || animation.phase > 6.2832)) errors.push('Animation phase must be between 0 and 2π.');
+          }
+        }
+      });
+      const totalCells = Object.values(assets || {}).reduce((sum,asset) => sum + (asset && Number.isInteger(asset.width) && Number.isInteger(asset.height) ? asset.width * asset.height : 0),0);
+      if (totalCells > MAX_TOTAL_CELLS) errors.push('Total pixel asset area exceeds the scene budget.');
+    }
     const timeCycle = input.timeCycle;
     if (!Array.isArray(timeCycle) || timeCycle.length < 2) errors.push('timeCycle must contain at least two time stops.');
     else {
@@ -83,6 +128,7 @@
     if (Array.isArray(input.pixels) && isPlainObject(palettes)) {
       const symbols = new Set();
       input.pixels.forEach(row => { if (typeof row === 'string') for (const symbol of row) symbols.add(symbol); });
+      if (input.schemaVersion === 2 && isPlainObject(assets)) Object.values(assets).forEach(asset => { if (asset && Array.isArray(asset.pixels)) asset.pixels.forEach(row => { if (typeof row === 'string') for (const symbol of row) symbols.add(symbol); }); });
       if (symbols.size > MAX_SYMBOLS) errors.push('pixels cannot use more than 64 unique symbols.');
       Object.keys(palettes).forEach(name => {
         const palette = palettes[name];

package/schemas/scene-manifest.v2.schema.json

@@ -0,0 +1,229 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://gsvegetable.github.io/pixel-daylight-switch/schemas/scene-manifest.v2.schema.json",
+  "title": "Pixel Daylight Switch Scene Manifest v2",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "id",
+    "name",
+    "author",
+    "license",
+    "canvas",
+    "pixels",
+    "palettes",
+    "timeCycle",
+    "assets",
+    "layers"
+  ],
+  "properties": {
+    "schemaVersion": {
+      "const": 2
+    },
+    "id": {
+      "type": "string",
+      "minLength": 3,
+      "maxLength": 64,
+      "pattern": "^[a-z0-9][a-z0-9._-]{1,62}[a-z0-9]$"
+    },
+    "name": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 80
+    },
+    "author": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 80
+    },
+    "license": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 64
+    },
+    "canvas": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "width",
+        "height"
+      ],
+      "properties": {
+        "width": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 192
+        },
+        "height": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 112
+        }
+      }
+    },
+    "pixels": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 112,
+      "items": {
+        "type": "string",
+        "minLength": 1,
+        "maxLength": 192,
+        "pattern": "^[\\x20-\\x7E]+$"
+      }
+    },
+    "palettes": {
+      "type": "object",
+      "minProperties": 1,
+      "maxProperties": 8,
+      "additionalProperties": {
+        "type": "object",
+        "maxProperties": 64,
+        "propertyNames": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 1,
+          "pattern": "^[\\u0020-\\u007E]$"
+        },
+        "additionalProperties": {
+          "type": "string",
+          "pattern": "^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$"
+        }
+      }
+    },
+    "timeCycle": {
+      "type": "array",
+      "minItems": 2,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "at",
+          "palette"
+        ],
+        "properties": {
+          "at": {
+            "type": "number",
+            "minimum": 0,
+            "maximum": 24
+          },
+          "palette": {
+            "type": "string"
+          }
+        }
+      },
+      "maxItems": 48
+    },
+    "assets": {
+      "type": "object",
+      "minProperties": 1,
+      "maxProperties": 24,
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "width",
+          "height",
+          "pixels"
+        ],
+        "properties": {
+          "width": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 192
+          },
+          "height": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 112
+          },
+          "pixels": {
+            "type": "array",
+            "minItems": 1,
+            "maxItems": 112,
+            "items": {
+              "type": "string",
+              "minLength": 1,
+              "maxLength": 192,
+              "pattern": "^[\\x20-\\x7E]+$"
+            }
+          }
+        }
+      }
+    },
+    "layers": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 16,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "id",
+          "asset",
+          "x",
+          "y"
+        ],
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^[a-z0-9][a-z0-9._-]{0,47}$"
+          },
+          "asset": {
+            "type": "string"
+          },
+          "x": {
+            "type": "integer",
+            "minimum": -192,
+            "maximum": 192
+          },
+          "y": {
+            "type": "integer",
+            "minimum": -112,
+            "maximum": 112
+          },
+          "animation": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+              "type",
+              "axis",
+              "speed",
+              "distance"
+            ],
+            "properties": {
+              "type": {
+                "enum": [
+                  "drift",
+                  "bob"
+                ]
+              },
+              "axis": {
+                "enum": [
+                  "x",
+                  "y"
+                ]
+              },
+              "speed": {
+                "type": "number",
+                "minimum": 0,
+                "maximum": 4
+              },
+              "distance": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 64
+              },
+              "phase": {
+                "type": "number",
+                "minimum": 0,
+                "maximum": 6.2832
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}