valence-cli 1.2.8 → 1.3.1

package/dist/templates/native.js

@@ -0,0 +1,40 @@
+export const nativePackageJson = `
+{
+  "name": "native",
+  "version": "0.1.0",
+  "main": "index.node",
+  "scripts": {
+    "build": "neon build --release",
+    "debug": "neon build --debug"
+  },
+  "devDependencies": {}
+}
+`;
+export const nativeCargoToml = `
+[package]
+name = "native"
+version = "0.1.0"
+edition = "2021"
+exclude = ["index.node"]
+
+[lib]
+name = "native"
+crate-type = ["cdylib"]
+
+[dependencies]
+neon = "0.10"
+`;
+export const nativeLibRs = `
+use neon::prelude::*;
+
+fn hello(mut cx: FunctionContext) -> JsResult<JsString> {
+    Ok(cx.string("Hello from Rust!"))
+}
+
+#[neon::main]
+fn main(mut cx: ModuleContext) -> NeonResult<()> {
+    cx.export_function("hello", hello)?;
+    Ok(())
+}
+`;
+//# sourceMappingURL=native.js.map

package/dist/templates/native.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native.js","sourceRoot":"","sources":["../../src/templates/native.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,MAAM,iBAAiB,GAAG;;;;;;;;;;;CAWhC,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;CAa9B,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;;CAY1B,CAAC"}

package/dist/templates/phaser-scene.d.ts

@@ -0,0 +1,2 @@
+export declare const phaserSceneTemplate: (name: string, className: string) => string;
+//# sourceMappingURL=phaser-scene.d.ts.map

package/dist/templates/phaser-scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phaser-scene.d.ts","sourceRoot":"","sources":["../../src/templates/phaser-scene.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,EAAE,WAAW,MAAM,WAyBlE,CAAC"}

package/dist/templates/phaser-scene.js

@@ -0,0 +1,27 @@
+export const phaserSceneTemplate = (name, className) => `
+import Phaser from 'phaser';
+
+export class ${className} extends Phaser.Scene {
+    constructor() {
+        super({ key: '${className}' });
+    }
+
+    preload() {
+        // Load assets
+    }
+
+    create() {
+        const { width, height } = this.scale;
+        
+        this.add.text(width / 2, height / 2, 'Scene: ${name}', {
+            fontSize: '32px',
+            color: '#ffffff'
+        }).setOrigin(0.5);
+    }
+
+    update(time: number, delta: number) {
+        // Game loop
+    }
+}
+`;
+//# sourceMappingURL=phaser-scene.js.map

package/dist/templates/phaser-scene.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"phaser-scene.js","sourceRoot":"","sources":["../../src/templates/phaser-scene.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,IAAY,EAAE,SAAiB,EAAE,EAAE,CAAC;;;eAGzD,SAAS;;wBAEA,SAAS;;;;;;;;;;uDAUsB,IAAI;;;;;;;;;;CAU1D,CAAC"}

package/dist/templates/phaser.d.ts

@@ -0,0 +1,2 @@
+export declare const phaserEngineServiceTemplate = "\nimport { Injectable, NgZone, ElementRef, OnDestroy, signal, WritableSignal } from '@angular/core';\nimport Phaser from 'phaser';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class PhaserEngineService implements OnDestroy {\n  public game: Phaser.Game | null = null;\n  public fps: WritableSignal<string> = signal('0');\n  public rotation: WritableSignal<string> = signal('2D Mode');\n  \n  private canvas: HTMLCanvasElement | null = null;\n\n  constructor(private ngZone: NgZone) {}\n\n  public initGame(canvas: HTMLCanvasElement) {\n    this.canvas = canvas;\n    this.ngZone.runOutsideAngular(() => {\n        if (!this.game) {\n            this.createGame();\n        }\n    });\n  }\n\n  private createGame() {\n    if (!this.canvas) return;\n\n    const config: Phaser.Types.Core.GameConfig = {\n      type: Phaser.WEBGL,\n      canvas: this.canvas,\n      width: window.innerWidth,\n      height: window.innerHeight,\n      backgroundColor: '#0d0d0d', // Match 3D background\n      physics: {\n          default: 'arcade',\n          arcade: {\n              gravity: { x: 0, y: 0 },\n              debug: false\n          }\n      },\n      scene: [MainScene],\n      scale: {\n          mode: Phaser.Scale.RESIZE,\n          autoCenter: Phaser.Scale.CENTER_BOTH\n      },\n      callbacks: {\n          postBoot: (game) => {\n             // Hook into the loop for stats\n             const originalStep = game.loop.step;\n             game.loop.step = (time: number, delta: number) => {\n                 originalStep.call(game.loop, time, delta);\n                 this.fps.set(game.loop.actualFps.toFixed(0));\n             };\n          }\n      }\n    };\n\n    this.game = new Phaser.Game(config);\n    \n    window.addEventListener('resize', this.onResize.bind(this));\n  }\n\n  private onResize() {\n    if (this.game) {\n      this.game.scale.resize(window.innerWidth, window.innerHeight);\n    }\n  }\n\n  ngOnDestroy(): void {\n    if (this.game) {\n        this.game.destroy(true);\n        this.game = null;\n    }\n    window.removeEventListener('resize', this.onResize.bind(this));\n  }\n}\n\nclass MainScene extends Phaser.Scene {\n    private logoContainer!: Phaser.GameObjects.Container;\n\n    constructor() {\n        super({ key: 'MainScene' });\n    }\n\n    create() {\n        const centerX = this.scale.width / 2;\n        const centerY = this.scale.height / 2;\n\n        this.logoContainer = this.add.container(centerX, centerY);\n\n        // V Logo Graphics\n        const graphics = this.add.graphics();\n        \n        // Glow effect (simulated with multiple overlapping strokes)\n        graphics.lineStyle(4, 0x47848F, 0.3);\n        this.drawV(graphics, 6); // Outer glow\n        \n        graphics.lineStyle(2, 0x47848F, 1);\n        this.drawV(graphics, 0); // Main Stroke\n\n        // Red Accent\n        const accent = this.add.graphics();\n        accent.lineStyle(2, 0xDD0031, 1);\n        accent.beginPath();\n        accent.moveTo(-50, 0);\n        accent.lineTo(0, 100);\n        accent.strokePath();\n\n        this.logoContainer.add([graphics, accent]);\n\n        // Text\n        const text = this.add.text(0, 140, 'VALENCE 2D', {\n            fontFamily: 'Segoe UI',\n            fontSize: '32px',\n            color: '#ffffff',\n            align: 'center'\n        }).setOrigin(0.5);\n        \n        const subtext = this.add.text(0, 180, 'Angular + Electron + Phaser', {\n            fontFamily: 'Segoe UI',\n            fontSize: '14px',\n            color: '#888888',\n            align: 'center'\n        }).setOrigin(0.5);\n\n        this.logoContainer.add([text, subtext]);\n    }\n\n    private drawV(graphics: Phaser.GameObjects.Graphics, offset: number) {\n        // V Shape\n        graphics.beginPath();\n        graphics.moveTo(-50 - offset, -50 - offset);\n        graphics.lineTo(0, 50 + offset);\n        graphics.lineTo(50 + offset, -50 - offset);\n        graphics.strokePath();\n    }\n\n    update() {\n        if (this.logoContainer) {\n            this.logoContainer.rotation = Math.sin(this.time.now / 1000) * 0.05;\n            this.logoContainer.scale = 1 + Math.sin(this.time.now / 2000) * 0.02;\n        }\n    }\n}\n";
+//# sourceMappingURL=phaser.d.ts.map

package/dist/templates/phaser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phaser.d.ts","sourceRoot":"","sources":["../../src/templates/phaser.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,8nIAiJvC,CAAC"}

package/dist/templates/phaser.js

@@ -0,0 +1,147 @@
+export const phaserEngineServiceTemplate = `
+import { Injectable, NgZone, ElementRef, OnDestroy, signal, WritableSignal } from '@angular/core';
+import Phaser from 'phaser';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class PhaserEngineService implements OnDestroy {
+  public game: Phaser.Game | null = null;
+  public fps: WritableSignal<string> = signal('0');
+  public rotation: WritableSignal<string> = signal('2D Mode');
+  
+  private canvas: HTMLCanvasElement | null = null;
+
+  constructor(private ngZone: NgZone) {}
+
+  public initGame(canvas: HTMLCanvasElement) {
+    this.canvas = canvas;
+    this.ngZone.runOutsideAngular(() => {
+        if (!this.game) {
+            this.createGame();
+        }
+    });
+  }
+
+  private createGame() {
+    if (!this.canvas) return;
+
+    const config: Phaser.Types.Core.GameConfig = {
+      type: Phaser.WEBGL,
+      canvas: this.canvas,
+      width: window.innerWidth,
+      height: window.innerHeight,
+      backgroundColor: '#0d0d0d', // Match 3D background
+      physics: {
+          default: 'arcade',
+          arcade: {
+              gravity: { x: 0, y: 0 },
+              debug: false
+          }
+      },
+      scene: [MainScene],
+      scale: {
+          mode: Phaser.Scale.RESIZE,
+          autoCenter: Phaser.Scale.CENTER_BOTH
+      },
+      callbacks: {
+          postBoot: (game) => {
+             // Hook into the loop for stats
+             const originalStep = game.loop.step;
+             game.loop.step = (time: number, delta: number) => {
+                 originalStep.call(game.loop, time, delta);
+                 this.fps.set(game.loop.actualFps.toFixed(0));
+             };
+          }
+      }
+    };
+
+    this.game = new Phaser.Game(config);
+    
+    window.addEventListener('resize', this.onResize.bind(this));
+  }
+
+  private onResize() {
+    if (this.game) {
+      this.game.scale.resize(window.innerWidth, window.innerHeight);
+    }
+  }
+
+  ngOnDestroy(): void {
+    if (this.game) {
+        this.game.destroy(true);
+        this.game = null;
+    }
+    window.removeEventListener('resize', this.onResize.bind(this));
+  }
+}
+
+class MainScene extends Phaser.Scene {
+    private logoContainer!: Phaser.GameObjects.Container;
+
+    constructor() {
+        super({ key: 'MainScene' });
+    }
+
+    create() {
+        const centerX = this.scale.width / 2;
+        const centerY = this.scale.height / 2;
+
+        this.logoContainer = this.add.container(centerX, centerY);
+
+        // V Logo Graphics
+        const graphics = this.add.graphics();
+        
+        // Glow effect (simulated with multiple overlapping strokes)
+        graphics.lineStyle(4, 0x47848F, 0.3);
+        this.drawV(graphics, 6); // Outer glow
+        
+        graphics.lineStyle(2, 0x47848F, 1);
+        this.drawV(graphics, 0); // Main Stroke
+
+        // Red Accent
+        const accent = this.add.graphics();
+        accent.lineStyle(2, 0xDD0031, 1);
+        accent.beginPath();
+        accent.moveTo(-50, 0);
+        accent.lineTo(0, 100);
+        accent.strokePath();
+
+        this.logoContainer.add([graphics, accent]);
+
+        // Text
+        const text = this.add.text(0, 140, 'VALENCE 2D', {
+            fontFamily: 'Segoe UI',
+            fontSize: '32px',
+            color: '#ffffff',
+            align: 'center'
+        }).setOrigin(0.5);
+        
+        const subtext = this.add.text(0, 180, 'Angular + Electron + Phaser', {
+            fontFamily: 'Segoe UI',
+            fontSize: '14px',
+            color: '#888888',
+            align: 'center'
+        }).setOrigin(0.5);
+
+        this.logoContainer.add([text, subtext]);
+    }
+
+    private drawV(graphics: Phaser.GameObjects.Graphics, offset: number) {
+        // V Shape
+        graphics.beginPath();
+        graphics.moveTo(-50 - offset, -50 - offset);
+        graphics.lineTo(0, 50 + offset);
+        graphics.lineTo(50 + offset, -50 - offset);
+        graphics.strokePath();
+    }
+
+    update() {
+        if (this.logoContainer) {
+            this.logoContainer.rotation = Math.sin(this.time.now / 1000) * 0.05;
+            this.logoContainer.scale = 1 + Math.sin(this.time.now / 2000) * 0.02;
+        }
+    }
+}
+`;
+//# sourceMappingURL=phaser.js.map

package/dist/templates/phaser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"phaser.js","sourceRoot":"","sources":["../../src/templates/phaser.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,2BAA2B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiJ1C,CAAC"}

package/dist/templates/settings.d.ts

@@ -0,0 +1,2 @@
+export declare const settingsServiceTemplate = "\nimport { Injectable, signal, effect } from '@angular/core';\nimport { StorageService } from '../storage/storage.service';\nimport { AudioService, SoundChannel } from '../audio/audio.service';\n\nexport interface GameSettings {\n  audio: {\n    master: number;\n    music: number;\n    sfx: number;\n  };\n  graphics: {\n    resolutionScale: number;\n    antialiasing: boolean;\n  };\n}\n\nconst DEFAULT_SETTINGS: GameSettings = {\n  audio: { master: 1.0, music: 0.8, sfx: 1.0 },\n  graphics: { resolutionScale: 1.0, antialiasing: true }\n};\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class SettingsService {\n\n  public settings = signal<GameSettings>(DEFAULT_SETTINGS);\n\n  constructor(\n    private storage: StorageService,\n    private audio: AudioService\n  ) {\n\n    // Auto-save on change (debounced effect could be better, but simple for now)\n    effect(() => {\n      const s = this.settings();\n      this.applySettings(s);\n      this.storage.save('settings', s);\n    });\n  }\n\n  private async loadSettings() {\n    const saved = await this.storage.load<GameSettings>('settings');\n    if (saved) {\n      this.settings.set({ ...DEFAULT_SETTINGS, ...saved });\n    }\n  }\n\n  private applySettings(s: GameSettings) {\n    this.audio.setVolume(SoundChannel.MASTER, s.audio.master);\n    this.audio.setVolume(SoundChannel.MUSIC, s.audio.music);\n    this.audio.setVolume(SoundChannel.SFX, s.audio.sfx);\n    \n    // Graphics would typically be pulled by the EngineService from this signal\n  }\n\n  public updateAudio(channel: keyof GameSettings['audio'], value: number) {\n    this.settings.update(s => ({\n      ...s,\n      audio: { ...s.audio, [channel]: value }\n    }));\n  }\n}\n";
+//# sourceMappingURL=settings.d.ts.map

package/dist/templates/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/templates/settings.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,qrDAgEnC,CAAC"}

package/dist/templates/settings.js

@@ -0,0 +1,66 @@
+export const settingsServiceTemplate = `
+import { Injectable, signal, effect } from '@angular/core';
+import { StorageService } from '../storage/storage.service';
+import { AudioService, SoundChannel } from '../audio/audio.service';
+
+export interface GameSettings {
+  audio: {
+    master: number;
+    music: number;
+    sfx: number;
+  };
+  graphics: {
+    resolutionScale: number;
+    antialiasing: boolean;
+  };
+}
+
+const DEFAULT_SETTINGS: GameSettings = {
+  audio: { master: 1.0, music: 0.8, sfx: 1.0 },
+  graphics: { resolutionScale: 1.0, antialiasing: true }
+};
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SettingsService {
+
+  public settings = signal<GameSettings>(DEFAULT_SETTINGS);
+
+  constructor(
+    private storage: StorageService,
+    private audio: AudioService
+  ) {
+
+    // Auto-save on change (debounced effect could be better, but simple for now)
+    effect(() => {
+      const s = this.settings();
+      this.applySettings(s);
+      this.storage.save('settings', s);
+    });
+  }
+
+  private async loadSettings() {
+    const saved = await this.storage.load<GameSettings>('settings');
+    if (saved) {
+      this.settings.set({ ...DEFAULT_SETTINGS, ...saved });
+    }
+  }
+
+  private applySettings(s: GameSettings) {
+    this.audio.setVolume(SoundChannel.MASTER, s.audio.master);
+    this.audio.setVolume(SoundChannel.MUSIC, s.audio.music);
+    this.audio.setVolume(SoundChannel.SFX, s.audio.sfx);
+    
+    // Graphics would typically be pulled by the EngineService from this signal
+  }
+
+  public updateAudio(channel: keyof GameSettings['audio'], value: number) {
+    this.settings.update(s => ({
+      ...s,
+      audio: { ...s.audio, [channel]: value }
+    }));
+  }
+}
+`;
+//# sourceMappingURL=settings.js.map

package/dist/templates/settings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.js","sourceRoot":"","sources":["../../src/templates/settings.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,uBAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgEtC,CAAC"}

package/dist/templates/state.d.ts

@@ -0,0 +1,2 @@
+export declare const gameStateServiceTemplate = "\nimport { Injectable, signal, computed } from '@angular/core';\n\nexport enum GameState {\n  BOOT = 'boot',\n  MAIN_MENU = 'main_menu',\n  LOADING = 'loading',\n  GAMEPLAY = 'gameplay',\n  PAUSED = 'paused',\n  GAME_OVER = 'game_over'\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class GameStateService {\n  \n  private _state = signal<GameState>(GameState.BOOT);\n  public state = this._state.asReadonly();\n\n  // Computed checks for UI bindings\n  public isMenu = computed(() => this._state() === GameState.MAIN_MENU);\n  public isGameplay = computed(() => this._state() === GameState.GAMEPLAY);\n  public isPaused = computed(() => this._state() === GameState.PAUSED);\n\n  public set(newState: GameState) {\n    console.log(`Game State Change: ${this._state()} -> ${newState}`);\n    this._state.set(newState);\n    \n    // Trigger side effects here (e.g. pause engine, show overlay)\n    // ValenceEngineService can listen to this signal.\n  }\n}\n";
+//# sourceMappingURL=state.d.ts.map

package/dist/templates/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/templates/state.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,wBAAwB,y8BAiCpC,CAAC"}

package/dist/templates/state.js

@@ -0,0 +1,35 @@
+export const gameStateServiceTemplate = `
+import { Injectable, signal, computed } from '@angular/core';
+
+export enum GameState {
+  BOOT = 'boot',
+  MAIN_MENU = 'main_menu',
+  LOADING = 'loading',
+  GAMEPLAY = 'gameplay',
+  PAUSED = 'paused',
+  GAME_OVER = 'game_over'
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class GameStateService {
+  
+  private _state = signal<GameState>(GameState.BOOT);
+  public state = this._state.asReadonly();
+
+  // Computed checks for UI bindings
+  public isMenu = computed(() => this._state() === GameState.MAIN_MENU);
+  public isGameplay = computed(() => this._state() === GameState.GAMEPLAY);
+  public isPaused = computed(() => this._state() === GameState.PAUSED);
+
+  public set(newState: GameState) {
+    console.log(\`Game State Change: \${this._state()} -> \${newState}\`);
+    this._state.set(newState);
+    
+    // Trigger side effects here (e.g. pause engine, show overlay)
+    // ValenceEngineService can listen to this signal.
+  }
+}
+`;
+//# sourceMappingURL=state.js.map

package/dist/templates/state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.js","sourceRoot":"","sources":["../../src/templates/state.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,wBAAwB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCvC,CAAC"}

package/dist/templates/storage.d.ts

@@ -0,0 +1,4 @@
+export declare const storageServiceTemplate = "\nimport { Injectable } from '@angular/core';\n\nexport interface StorageBridge {\n  save: (key: string, data: string) => Promise<boolean>;\n  load: (key: string) => Promise<string | null>;\n  exists: (key: string) => Promise<boolean>;\n  delete: (key: string) => Promise<boolean>;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class StorageService {\n  \n  private bridge?: StorageBridge;\n\n  constructor() {\n    const w = window as unknown as { valenceStorage?: StorageBridge };\n    if (w.valenceStorage) {\n      this.bridge = w.valenceStorage;\n    } else {\n      console.warn('Valence Storage Bridge not found. Data will be volatile (localStorage fallback).');\n    }\n  }\n\n  public async save(key: string, data: unknown): Promise<boolean> {\n    const serialized = JSON.stringify(data);\n    if (this.bridge) {\n      return await this.bridge.save(key, serialized);\n    }\n    localStorage.setItem(key, serialized);\n    return true;\n  }\n\n  public async load<T>(key: string): Promise<T | null> {\n    if (this.bridge) {\n      const raw = await this.bridge.load(key);\n      if (!raw) return null;\n      try { return JSON.parse(raw); } catch { return null; }\n    }\n    const raw = localStorage.getItem(key);\n    return raw ? JSON.parse(raw) : null;\n  }\n\n  public async delete(key: string): Promise<boolean> {\n    if (this.bridge) {\n      return await this.bridge.delete(key);\n    }\n    localStorage.removeItem(key);\n    return true;\n  }\n}\n";
+export declare const storageBridgeTemplate = "\n// VALENCE: STORAGE_IPC\n// VALENCE: STORAGE_IPC\n// (Imports handled by injector)\n\n// Store data in User Data directory\nconst STORAGE_PATH = path.join(app.getPath('userData'), 'saves');\n\nif (!fs.existsSync(STORAGE_PATH)) {\n  fs.mkdirSync(STORAGE_PATH, { recursive: true });\n}\n\nipcMain.handle('storage:save', async (_, key: string, data: string) => {\n  try {\n    const target = path.join(STORAGE_PATH, `${key}.json`);\n    const temp = `${target}.tmp`;\n    await fs.promises.writeFile(temp, data, 'utf8');\n    await fs.promises.rename(temp, target); // Atomic write\n    return true;\n  } catch (e) {\n    console.error('Storage Save Error:', e);\n    return false;\n  }\n});\n\nipcMain.handle('storage:load', async (_, key: string) => {\n  try {\n    const target = path.join(STORAGE_PATH, `${key}.json`);\n    if (fs.existsSync(target)) {\n       return await fs.promises.readFile(target, 'utf8');\n    }\n    return null;\n  } catch (e) {\n    console.error('Storage Load Error:', e);\n    return null;\n  }\n});\n\nipcMain.handle('storage:delete', async (_, key: string) => {\n  try {\n    const target = path.join(STORAGE_PATH, `${key}.json`);\n    if (fs.existsSync(target)) {\n       await fs.promises.unlink(target);\n    }\n    return true;\n  } catch (e) {\n    return false;\n  }\n});\n\nipcMain.handle('storage:exists', async (_, key: string) => {\n  const target = path.join(STORAGE_PATH, `${key}.json`);\n  return fs.existsSync(target);\n});\n";
+export declare const storagePreloadTemplate = "\n// VALENCE: STORAGE_PRELOAD\nimport { contextBridge, ipcRenderer } from 'electron';\n\ncontextBridge.exposeInMainWorld('valenceStorage', {\n  save: (key: string, data: string) => ipcRenderer.invoke('storage:save', key, data),\n  load: (key: string) => ipcRenderer.invoke('storage:load', key),\n  delete: (key: string) => ipcRenderer.invoke('storage:delete', key),\n  exists: (key: string) => ipcRenderer.invoke('storage:exists', key),\n});\n";
+//# sourceMappingURL=storage.d.ts.map

package/dist/templates/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/templates/storage.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,28CAqDlC,CAAC;AAEF,eAAO,MAAM,qBAAqB,q8CAsDjC,CAAC;AAEF,eAAO,MAAM,sBAAsB,gcAUlC,CAAC"}

package/dist/templates/storage.js

@@ -0,0 +1,121 @@
+export const storageServiceTemplate = `
+import { Injectable } from '@angular/core';
+
+export interface StorageBridge {
+  save: (key: string, data: string) => Promise<boolean>;
+  load: (key: string) => Promise<string | null>;
+  exists: (key: string) => Promise<boolean>;
+  delete: (key: string) => Promise<boolean>;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class StorageService {
+  
+  private bridge?: StorageBridge;
+
+  constructor() {
+    const w = window as unknown as { valenceStorage?: StorageBridge };
+    if (w.valenceStorage) {
+      this.bridge = w.valenceStorage;
+    } else {
+      console.warn('Valence Storage Bridge not found. Data will be volatile (localStorage fallback).');
+    }
+  }
+
+  public async save(key: string, data: unknown): Promise<boolean> {
+    const serialized = JSON.stringify(data);
+    if (this.bridge) {
+      return await this.bridge.save(key, serialized);
+    }
+    localStorage.setItem(key, serialized);
+    return true;
+  }
+
+  public async load<T>(key: string): Promise<T | null> {
+    if (this.bridge) {
+      const raw = await this.bridge.load(key);
+      if (!raw) return null;
+      try { return JSON.parse(raw); } catch { return null; }
+    }
+    const raw = localStorage.getItem(key);
+    return raw ? JSON.parse(raw) : null;
+  }
+
+  public async delete(key: string): Promise<boolean> {
+    if (this.bridge) {
+      return await this.bridge.delete(key);
+    }
+    localStorage.removeItem(key);
+    return true;
+  }
+}
+`;
+export const storageBridgeTemplate = `
+// VALENCE: STORAGE_IPC
+// VALENCE: STORAGE_IPC
+// (Imports handled by injector)
+
+// Store data in User Data directory
+const STORAGE_PATH = path.join(app.getPath('userData'), 'saves');
+
+if (!fs.existsSync(STORAGE_PATH)) {
+  fs.mkdirSync(STORAGE_PATH, { recursive: true });
+}
+
+ipcMain.handle('storage:save', async (_, key: string, data: string) => {
+  try {
+    const target = path.join(STORAGE_PATH, \`\${key}.json\`);
+    const temp = \`\${target}.tmp\`;
+    await fs.promises.writeFile(temp, data, 'utf8');
+    await fs.promises.rename(temp, target); // Atomic write
+    return true;
+  } catch (e) {
+    console.error('Storage Save Error:', e);
+    return false;
+  }
+});
+
+ipcMain.handle('storage:load', async (_, key: string) => {
+  try {
+    const target = path.join(STORAGE_PATH, \`\${key}.json\`);
+    if (fs.existsSync(target)) {
+       return await fs.promises.readFile(target, 'utf8');
+    }
+    return null;
+  } catch (e) {
+    console.error('Storage Load Error:', e);
+    return null;
+  }
+});
+
+ipcMain.handle('storage:delete', async (_, key: string) => {
+  try {
+    const target = path.join(STORAGE_PATH, \`\${key}.json\`);
+    if (fs.existsSync(target)) {
+       await fs.promises.unlink(target);
+    }
+    return true;
+  } catch (e) {
+    return false;
+  }
+});
+
+ipcMain.handle('storage:exists', async (_, key: string) => {
+  const target = path.join(STORAGE_PATH, \`\${key}.json\`);
+  return fs.existsSync(target);
+});
+`;
+export const storagePreloadTemplate = `
+// VALENCE: STORAGE_PRELOAD
+import { contextBridge, ipcRenderer } from 'electron';
+
+contextBridge.exposeInMainWorld('valenceStorage', {
+  save: (key: string, data: string) => ipcRenderer.invoke('storage:save', key, data),
+  load: (key: string) => ipcRenderer.invoke('storage:load', key),
+  delete: (key: string) => ipcRenderer.invoke('storage:delete', key),
+  exists: (key: string) => ipcRenderer.invoke('storage:exists', key),
+});
+`;
+//# sourceMappingURL=storage.js.map

package/dist/templates/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../src/templates/storage.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDrC,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsDpC,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG;;;;;;;;;;CAUrC,CAAC"}

package/dist/templates.d.ts

@@ -1,2 +1,4 @@
 export * from './templates/index.js';
+export * from './templates/phaser.js';
+export * from './templates/phaser-scene.js';
 //# sourceMappingURL=templates.d.ts.map

package/dist/templates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../src/templates.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../src/templates.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC"}