@nexart/codemode-sdk 1.5.0 → 1.6.0

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AACnE,YAAY,EACV,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EAChB,YAAY,EACZ,aAAa,GACd,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAKH,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AACpE,YAAY,EACV,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAK5C,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,YAAY,EACV,MAAM,EACN,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,aAAa,GACd,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAGzC,OAAO,EACL,yBAAyB,EACzB,oBAAoB,EACpB,0BAA0B,EAC1B,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,GACtB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,mBAAmB,EACnB,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,uBAAuB,EACvB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,KAAK,YAAY,EACjB,KAAK,YAAY,GAClB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,iBAAiB,EACjB,4BAA4B,EAC5B,yBAAyB,EACzB,KAAK,kBAAkB,GACxB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,eAAe,EAAE,KAAK,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAGrF,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,yBAAyB,EACzB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,aAAa,GACnB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,KAAK,YAAY,GAClB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,cAAc,EACd,4BAA4B,EAC5B,kBAAkB,EAClB,KAAK,eAAe,GACrB,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -1,6 +1,6 @@
 /**
  * NexArt Code Mode Runtime SDK
- * Version: 1.5.0 (Protocol v1.2.0)
+ * Version: 1.1.0 (Protocol v1.0.0)
  *
  * ╔══════════════════════════════════════════════════════════════════════════╗
  * ║  @nexart/codemode-sdk — Canonical Code Mode Authority                    ║
@@ -10,9 +10,9 @@
  * ║                                                                          ║
  * ║  Protocol: nexart                                                        ║
  * ║  Engine: codemode                                                        ║
- * ║  SDK Version: 1.5.0                                                      ║
- * ║  Protocol Version: 1.2.0                                                 ║
- * ║  Phase: 3                                                                ║
+ * ║  SDK Version: 1.1.0                                                      ║
+ * ║  Protocol Version: 1.0.0                                                 ║
+ * ║  Phase: 1                                                                ║
  * ║  Enforcement: HARD                                                       ║
  * ╚══════════════════════════════════════════════════════════════════════════╝
  *
@@ -21,21 +21,35 @@
  * import { executeCodeMode } from '@nexart/codemode-sdk';
  *
  * const result = await executeCodeMode({
- *   source: `
- *     function setup() {
- *       background(255);
- *       fill(0);
- *       ellipse(width/2, height/2, 100);
- *     }
- *   `,
- *   mode: 'static',
+ *   source: `function setup() { background(255); ellipse(width/2, height/2, 100); }`,
  *   width: 1950,
  *   height: 2400,
  *   seed: 12345,
- *   vars: [50, 50, 50, 50, 50, 50, 50, 50, 50, 50]
+ *   vars: [50, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ *   mode: 'static'
  * });
- * console.log('Rendered:', result.blob.size, 'bytes');
+ *
+ * console.log(result.metadata.protocolVersion); // '1.0.0'
  * ```
  */
-export { executeCodeMode, validateCodeModeSource } from './engine';
-export { DEFAULT_CONFIG, PROTOCOL_IDENTITY } from './types';
+// ═══════════════════════════════════════════════════════════════════════════
+// CANONICAL EXECUTION ENTRY POINT
+// ═══════════════════════════════════════════════════════════════════════════
+export { executeCodeMode, validateCodeModeSource } from './execute';
+export { PROTOCOL_IDENTITY } from './types';
+// ═══════════════════════════════════════════════════════════════════════════
+// LEGACY ENGINE API (use executeCodeMode for new implementations)
+// ═══════════════════════════════════════════════════════════════════════════
+export { createEngine } from './engine';
+export { DEFAULT_CONFIG } from './types';
+// SoundArt → Code Mode integration
+export { renderSoundArtViaCodeMode, canRenderViaCodeMode, getCodeModeAvailableStyles, } from './soundart-engine';
+export { createSoundSnapshot, createEmptySoundSnapshot, freezeSoundSnapshot, } from '../../shared/soundSnapshot';
+export { injectSoundGlobals, createSoundGlobals, createEmptySoundGlobals, generateSoundPalette, inferGenreProfile, createSoundHelpers, } from './sound-bridge';
+export { getSoundArtSketch, getAvailableSoundArtSketches, isSoundArtSketchAvailable, } from './soundart-sketches';
+export { createP5Runtime } from './p5-runtime';
+// Noise → Code Mode integration
+export { renderNoiseViaCodeMode, compileNoiseSystem, canRenderNoiseViaCodeMode, } from './noise-engine';
+export { createNoiseSnapshot, validateNoiseSnapshot, } from '../../shared/noiseSnapshot';
+export { createNoiseGlobals, injectNoiseGlobals, } from './noise-bridge';
+export { getNoiseSketch, getAvailableNoiseSketchNames, isValidNoiseSketch, } from './noise-sketches';

package/dist/loop-engine.d.ts

@@ -12,6 +12,9 @@
  *
  * Determinism Guarantee:
  * Same code + same seed + same VARs = identical frame sequence
+ *
+ * Security:
+ * All external entropy sources are blocked at runtime via execution sandbox.
  */
 import type { EngineConfig, RunOptions } from './types';
 export declare function cancelLoopMode(): void;

package/dist/loop-engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loop-engine.d.ts","sourceRoot":"","sources":["../loop-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAA+B,MAAM,SAAS,CAAC;AAMrF,wBAAgB,cAAc,IAAI,IAAI,CAErC;AAED,wBAAsB,WAAW,CAC/B,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,IAAI,CAAC,CAuMf"}
+{"version":3,"file":"loop-engine.d.ts","sourceRoot":"","sources":["../loop-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAA+B,MAAM,SAAS,CAAC;AAOrF,wBAAgB,cAAc,IAAI,IAAI,CAErC;AAED,wBAAsB,WAAW,CAC/B,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,IAAI,CAAC,CA+Mf"}

package/dist/loop-engine.js

@@ -12,9 +12,13 @@
  *
  * Determinism Guarantee:
  * Same code + same seed + same VARs = identical frame sequence
+ *
+ * Security:
+ * All external entropy sources are blocked at runtime via execution sandbox.
  */
 import { DEFAULT_CONFIG } from './types';
 import { createP5Runtime, injectProtocolVariables } from './p5-runtime';
+import { FORBIDDEN_APIS, createSafeMath } from './execution-sandbox';
 let isCancelled = false;
 export function cancelLoopMode() {
     isCancelled = true;
@@ -72,16 +76,22 @@ export async function runLoopMode(config, options) {
         }
         // Inject totalFrames into runtime
         p.totalFrames = totalFrames;
-        // Create wrapped functions with p5 context, time variables, VAR, and totalFrames
-        const wrappedSetup = new Function('p', 'frameCount', 't', 'time', 'tGlobal', 'VAR', 'totalFrames', `with(p) { ${setupCode} }`);
-        const wrappedDraw = new Function('p', 'frameCount', 't', 'time', 'tGlobal', 'VAR', 'totalFrames', `with(p) { ${drawCode} }`);
+        // Create sandboxed execution context
+        // All forbidden APIs are injected as parameters to override globals
+        const safeMath = createSafeMath();
+        const forbiddenKeys = Object.keys(FORBIDDEN_APIS);
+        // Create wrapped functions with p5 context, time variables, VAR, totalFrames, and blocked globals
+        const wrappedSetup = new Function('p', 'frameCount', 't', 'time', 'tGlobal', 'VAR', 'totalFrames', 'Math', ...forbiddenKeys, `with(p) { ${setupCode} }`);
+        const wrappedDraw = new Function('p', 'frameCount', 't', 'time', 'tGlobal', 'VAR', 'totalFrames', 'Math', ...forbiddenKeys, `with(p) { ${drawCode} }`);
+        // Get forbidden values array for execution
+        const forbiddenValues = forbiddenKeys.map(k => FORBIDDEN_APIS[k]);
         onProgress?.({
             phase: 'setup',
             percent: 10,
             message: 'Executing setup()...',
         });
-        // Execute setup() once with time = 0, VAR, and totalFrames
-        wrappedSetup(p, 0, 0, 0, 0, p.VAR, totalFrames);
+        // Execute setup() once with time = 0, VAR, totalFrames, and sandboxed context
+        wrappedSetup(p, 0, 0, 0, 0, p.VAR, totalFrames, safeMath, ...forbiddenValues);
         // Capture frames
         const frames = [];
         onProgress?.({
@@ -108,8 +118,8 @@ export async function runLoopMode(config, options) {
             // 2. Reset blend mode to NORMAL (Protocol v1.1 requirement)
             // Prevents blend mode state from persisting across frames
             p.blendMode('NORMAL');
-            // Execute draw() with time variables, VAR, and totalFrames
-            wrappedDraw(p, frame, t, time, t, p.VAR, totalFrames);
+            // Execute draw() with time variables, VAR, totalFrames, and sandboxed context
+            wrappedDraw(p, frame, t, time, t, p.VAR, totalFrames, safeMath, ...forbiddenValues);
             // Capture frame as PNG blob
             const blob = await new Promise((resolve, reject) => {
                 canvas.toBlob((b) => b ? resolve(b) : reject(new Error(`Failed to capture frame ${frame}`)), 'image/png');

package/dist/noise-bridge.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Noise Bridge - Injects N.* globals into Code Mode runtime
+ *
+ * This is the bridge between NoiseSnapshot data and the Code Mode p5-runtime.
+ * It creates frozen N.* globals that noise sketches can access deterministically.
+ *
+ * Similar to sound-bridge.ts for SoundArt, but for Noise parameters.
+ */
+import type { NoiseSnapshot, NoiseBlendMode } from '../../shared/noiseSnapshot';
+/**
+ * The N.* global object type for noise sketches
+ */
+export interface NoiseGlobals {
+    scale: number;
+    octaves: number;
+    persistence: number;
+    lacunarity: number;
+    cellDensity: number;
+    cellDistortion: number;
+    blendMode: NoiseBlendMode;
+    isPerlinOnly: boolean;
+    isBlend: boolean;
+    isWarp: boolean;
+    isInterleave: boolean;
+    bgR: number;
+    bgG: number;
+    bgB: number;
+    noiseR: number;
+    noiseG: number;
+    noiseB: number;
+    seed: number;
+    zoom: number;
+}
+/**
+ * Create N.* globals from a NoiseSnapshot
+ */
+export declare function createNoiseGlobals(snapshot: NoiseSnapshot): NoiseGlobals;
+/**
+ * Inject N.* globals into code string
+ *
+ * This wraps the sketch code with N.* variable declarations
+ */
+export declare function injectNoiseGlobals(sketchCode: string, globals: NoiseGlobals): string;
+//# sourceMappingURL=noise-bridge.d.ts.map

package/dist/noise-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noise-bridge.d.ts","sourceRoot":"","sources":["../noise-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAEhF;;GAEG;AACH,MAAM,WAAW,YAAY;IAE3B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IAGnB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IAGvB,SAAS,EAAE,cAAc,CAAC;IAC1B,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,YAAY,EAAE,OAAO,CAAC;IAGtB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IAGf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,aAAa,GAAG,YAAY,CAsBxE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,MAAM,CA6BpF"}

package/dist/noise-bridge.js

@@ -0,0 +1,68 @@
+/**
+ * Noise Bridge - Injects N.* globals into Code Mode runtime
+ *
+ * This is the bridge between NoiseSnapshot data and the Code Mode p5-runtime.
+ * It creates frozen N.* globals that noise sketches can access deterministically.
+ *
+ * Similar to sound-bridge.ts for SoundArt, but for Noise parameters.
+ */
+/**
+ * Create N.* globals from a NoiseSnapshot
+ */
+export function createNoiseGlobals(snapshot) {
+    return Object.freeze({
+        scale: snapshot.scale,
+        octaves: snapshot.octaves,
+        persistence: snapshot.persistence,
+        lacunarity: snapshot.lacunarity,
+        cellDensity: snapshot.cellDensity,
+        cellDistortion: snapshot.cellDistortion,
+        blendMode: snapshot.blendMode,
+        isPerlinOnly: snapshot.blendMode === 'perlin_only',
+        isBlend: snapshot.blendMode === 'blend',
+        isWarp: snapshot.blendMode === 'warp',
+        isInterleave: snapshot.blendMode === 'interleave',
+        bgR: snapshot.bgR,
+        bgG: snapshot.bgG,
+        bgB: snapshot.bgB,
+        noiseR: snapshot.noiseR,
+        noiseG: snapshot.noiseG,
+        noiseB: snapshot.noiseB,
+        seed: snapshot.seed,
+        zoom: snapshot.zoomLevel,
+    });
+}
+/**
+ * Inject N.* globals into code string
+ *
+ * This wraps the sketch code with N.* variable declarations
+ */
+export function injectNoiseGlobals(sketchCode, globals) {
+    const injection = `
+// === Injected Noise Globals (N.*) ===
+const N = Object.freeze({
+  scale: ${globals.scale},
+  octaves: ${globals.octaves},
+  persistence: ${globals.persistence},
+  lacunarity: ${globals.lacunarity},
+  cellDensity: ${globals.cellDensity},
+  cellDistortion: ${globals.cellDistortion},
+  blendMode: '${globals.blendMode}',
+  isPerlinOnly: ${globals.isPerlinOnly},
+  isBlend: ${globals.isBlend},
+  isWarp: ${globals.isWarp},
+  isInterleave: ${globals.isInterleave},
+  bgR: ${globals.bgR},
+  bgG: ${globals.bgG},
+  bgB: ${globals.bgB},
+  noiseR: ${globals.noiseR},
+  noiseG: ${globals.noiseG},
+  noiseB: ${globals.noiseB},
+  seed: ${globals.seed},
+  zoom: ${globals.zoom}
+});
+// === End Injected Globals ===
+
+`;
+    return injection + sketchCode;
+}

package/dist/noise-engine.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Noise → Code Mode Engine
+ *
+ * This is the orchestrator that runs Noise rendering through the Code Mode engine.
+ * It replaces the legacy p5.js-based NoiseCanvas with a protocol-compliant pipeline.
+ *
+ * Architecture:
+ *   1. NoiseParams from UI state
+ *   2. NoiseParams → NoiseSnapshot conversion
+ *   3. NoiseSnapshot injected as N.* globals into Code Mode
+ *   4. Noise sketch executed via Code Mode runtime
+ *   5. Result: PNG output (deterministic)
+ */
+import type { NoiseSnapshot, NoiseParams } from '../../shared/noiseSnapshot';
+export interface NoiseEngineConfig {
+    width: number;
+    height: number;
+    seed: number;
+}
+export interface NoiseRenderOptions {
+    params: NoiseParams;
+    canvas: HTMLCanvasElement;
+    config: NoiseEngineConfig;
+    onProgress?: (progress: number) => void;
+}
+export interface NoiseRenderResult {
+    mode: 'noise';
+    snapshot: NoiseSnapshot;
+    metadata: NoiseMetadata;
+}
+export interface NoiseMetadata {
+    mode: 'Noise';
+    timestamp: string;
+    enforcement: 'hard';
+    renderedVia: 'codemode';
+    noiseParams: {
+        scale: number;
+        octaves: number;
+        persistence: number;
+        lacunarity: number;
+        cellDensity: number;
+        cellDistortion: number;
+        blendMode: string;
+    };
+    generationParams: {
+        seed: number;
+        canvasSize: {
+            width: number;
+            height: number;
+        };
+    };
+}
+/**
+ * Render noise via Code Mode runtime
+ *
+ * This is the main entry point for protocol-compliant noise rendering.
+ * All rendering goes through the Code Mode runtime for determinism.
+ */
+export declare function renderNoiseViaCodeMode(options: NoiseRenderOptions): Promise<NoiseRenderResult>;
+/**
+ * Compile noise params to a Code Mode system
+ * This produces a reproducible system definition
+ */
+export declare function compileNoiseSystem(params: NoiseParams): {
+    sketchCode: string;
+    snapshot: NoiseSnapshot;
+    seed: number;
+};
+/**
+ * Check if noise can be rendered via Code Mode
+ * (Always true - no legacy fallback)
+ */
+export declare function canRenderNoiseViaCodeMode(): boolean;
+//# sourceMappingURL=noise-engine.d.ts.map

package/dist/noise-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noise-engine.d.ts","sourceRoot":"","sources":["../noise-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAM7E,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,aAAa,CAAC;IACxB,QAAQ,EAAE,aAAa,CAAC;CACzB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,UAAU,CAAC;IACxB,WAAW,EAAE;QACX,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;QACpB,cAAc,EAAE,MAAM,CAAC;QACvB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,gBAAgB,EAAE;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC;KAC/C,CAAC;CACH;AAED;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,iBAAiB,CAAC,CAsF5B;AAwBD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;CACd,CAUA;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,OAAO,CAEnD"}

package/dist/noise-engine.js

@@ -0,0 +1,132 @@
+/**
+ * Noise → Code Mode Engine
+ *
+ * This is the orchestrator that runs Noise rendering through the Code Mode engine.
+ * It replaces the legacy p5.js-based NoiseCanvas with a protocol-compliant pipeline.
+ *
+ * Architecture:
+ *   1. NoiseParams from UI state
+ *   2. NoiseParams → NoiseSnapshot conversion
+ *   3. NoiseSnapshot injected as N.* globals into Code Mode
+ *   4. Noise sketch executed via Code Mode runtime
+ *   5. Result: PNG output (deterministic)
+ */
+import { createNoiseSnapshot, validateNoiseSnapshot } from '../../shared/noiseSnapshot';
+import { createP5Runtime } from './p5-runtime';
+import { createNoiseGlobals, injectNoiseGlobals } from './noise-bridge';
+import { getNoiseSketch } from './noise-sketches';
+/**
+ * Render noise via Code Mode runtime
+ *
+ * This is the main entry point for protocol-compliant noise rendering.
+ * All rendering goes through the Code Mode runtime for determinism.
+ */
+export async function renderNoiseViaCodeMode(options) {
+    const { params, canvas, config, onProgress } = options;
+    // Protocol enforcement logging
+    console.log('[Noise] Protocol enforcement: HARD | renderedVia: codemode');
+    onProgress?.(0.1);
+    // Create and validate snapshot
+    const rawSnapshot = createNoiseSnapshot(params);
+    const snapshot = validateNoiseSnapshot(rawSnapshot);
+    onProgress?.(0.2);
+    // Create N.* globals
+    const noiseGlobals = createNoiseGlobals(snapshot);
+    // Get the noise sketch
+    const sketchName = 'fractalNoise';
+    const sketchCode = getNoiseSketch(sketchName);
+    // Inject N.* globals into sketch
+    const injectedCode = injectNoiseGlobals(sketchCode, noiseGlobals);
+    onProgress?.(0.3);
+    // Set canvas dimensions
+    canvas.width = config.width;
+    canvas.height = config.height;
+    // Create P5 runtime with correct signature
+    const runtimeConfig = {
+        seed: config.seed,
+    };
+    const runtime = createP5Runtime(canvas, config.width, config.height, runtimeConfig);
+    onProgress?.(0.5);
+    // Build globals with all runtime functions and noise globals
+    const globals = {
+        ...runtime,
+        width: config.width,
+        height: config.height,
+    };
+    // Execute the sketch
+    try {
+        executeNoiseSketch(injectedCode, globals);
+        onProgress?.(0.9);
+        console.log('[Noise] Rendered via Code Mode runtime');
+        // Build metadata
+        const metadata = {
+            mode: 'Noise',
+            timestamp: new Date().toISOString(),
+            enforcement: 'hard',
+            renderedVia: 'codemode',
+            noiseParams: {
+                scale: snapshot.scale,
+                octaves: snapshot.octaves,
+                persistence: snapshot.persistence,
+                lacunarity: snapshot.lacunarity,
+                cellDensity: snapshot.cellDensity,
+                cellDistortion: snapshot.cellDistortion,
+                blendMode: snapshot.blendMode,
+            },
+            generationParams: {
+                seed: config.seed,
+                canvasSize: { width: config.width, height: config.height },
+            },
+        };
+        onProgress?.(1.0);
+        return {
+            mode: 'noise',
+            snapshot,
+            metadata,
+        };
+    }
+    catch (error) {
+        console.error('[Noise] Code Mode execution failed:', error);
+        throw error;
+    }
+}
+/**
+ * Execute a noise sketch string in the context of the runtime globals
+ */
+function executeNoiseSketch(code, globals) {
+    const globalNames = Object.keys(globals);
+    const globalValues = Object.values(globals);
+    // Wrap the sketch code to call setup()
+    const wrappedCode = `
+    ${code}
+    
+    // Execute setup (noise is static - single frame)
+    if (typeof setup === 'function') {
+      setup();
+    }
+  `;
+    // Create and execute the function
+    const sketchFunction = new Function(...globalNames, wrappedCode);
+    sketchFunction(...globalValues);
+}
+/**
+ * Compile noise params to a Code Mode system
+ * This produces a reproducible system definition
+ */
+export function compileNoiseSystem(params) {
+    const snapshot = validateNoiseSnapshot(createNoiseSnapshot(params));
+    const noiseGlobals = createNoiseGlobals(snapshot);
+    const sketchCode = injectNoiseGlobals(getNoiseSketch('fractalNoise'), noiseGlobals);
+    return {
+        sketchCode,
+        snapshot,
+        seed: params.seed,
+    };
+}
+/**
+ * Check if noise can be rendered via Code Mode
+ * (Always true - no legacy fallback)
+ */
+export function canRenderNoiseViaCodeMode() {
+    return true;
+}

package/dist/noise-sketches/fractalNoise.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Fractal Noise - Code Mode Sketch
+ *
+ * This sketch implements Perlin FBM and Cellular noise rendering
+ * through the Code Mode p5-runtime. Uses N.* globals for all parameters.
+ *
+ * Original: client/src/components/noise-canvas-simple.tsx
+ */
+export declare const FRACTAL_NOISE_SKETCH = "\n// Fractal Noise - Code Mode Sketch\n// Uses N.* noise globals and standard p5-like functions\n\nfunction setup() {\n  // Set seeded random for reproducibility\n  randomSeed(N.seed);\n  noiseSeed(N.seed);\n  \n  // Set background color\n  background(N.bgR, N.bgG, N.bgB);\n  \n  // Noise rendering parameters\n  const adjustedScale = N.scale * (1 / N.zoom) * 0.05;\n  const cellSize = 4; // Fixed for quality\n  \n  // Generate cellular points if needed\n  const numPoints = Math.floor(20 + N.cellDensity * 180);\n  const cellPoints = [];\n  for (let i = 0; i < numPoints; i++) {\n    cellPoints.push([random(0, width), random(0, height)]);\n  }\n  \n  // Helper: Perlin FBM (Fractional Brownian Motion)\n  function perlinFBM(x, y, scale) {\n    let value = 0;\n    let amplitude = 1;\n    let frequency = 1;\n    let maxValue = 0;\n    \n    const oct = Math.min(N.octaves, 6); // Cap for performance\n    \n    for (let i = 0; i < oct; i++) {\n      value += noise(x * scale * frequency, y * scale * frequency) * amplitude;\n      maxValue += amplitude;\n      amplitude *= N.persistence;\n      frequency *= N.lacunarity;\n    }\n    \n    return value / maxValue;\n  }\n  \n  // Helper: Cellular noise (Worley)\n  function cellularNoise(x, y, points) {\n    let sampleX = x;\n    let sampleY = y;\n    \n    // Warp distortion if using warp mode\n    if (N.isWarp && N.cellDistortion > 0) {\n      const distortionAmount = N.cellDistortion * 100;\n      sampleX += noise(x * 0.01, y * 0.01) * distortionAmount;\n      sampleY += noise(y * 0.01, x * 0.01) * distortionAmount;\n    }\n    \n    // Find distances to closest points\n    let minDist = 999999;\n    let secondMinDist = 999999;\n    \n    for (let i = 0; i < points.length; i++) {\n      const px = points[i][0];\n      const py = points[i][1];\n      const dx = sampleX - px;\n      const dy = sampleY - py;\n      const dist = Math.sqrt(dx * dx + dy * dy);\n      \n      if (dist < minDist) {\n        secondMinDist = minDist;\n        minDist = dist;\n      } else if (dist < secondMinDist) {\n        secondMinDist = dist;\n      }\n    }\n    \n    // Normalize distance\n    return Math.min(1.0, (secondMinDist - minDist) / 50);\n  }\n  \n  // Render the noise grid\n  noStroke();\n  \n  for (let y = 0; y < height; y += cellSize) {\n    for (let x = 0; x < width; x += cellSize) {\n      // Calculate Perlin value\n      const perlinValue = perlinFBM(x, y, adjustedScale);\n      \n      // Calculate final value based on blend mode\n      let finalValue = perlinValue;\n      \n      if (!N.isPerlinOnly) {\n        const cellValue = cellularNoise(x, y, cellPoints);\n        \n        if (N.isBlend) {\n          finalValue = perlinValue * cellValue;\n        } else if (N.isWarp) {\n          finalValue = (perlinValue + cellValue) / 2;\n        } else if (N.isInterleave) {\n          finalValue = (Math.floor(x / 20) + Math.floor(y / 20)) % 2 === 0\n            ? perlinValue\n            : cellValue;\n        }\n      }\n      \n      // Set opacity based on noise value\n      const alpha = map(finalValue, 0, 1, 0, 255);\n      \n      // Fill with noise color and calculated alpha\n      fill(N.noiseR, N.noiseG, N.noiseB, alpha);\n      rect(x, y, cellSize, cellSize);\n    }\n  }\n}\n";
+export default FRACTAL_NOISE_SKETCH;
+//# sourceMappingURL=fractalNoise.d.ts.map

package/dist/noise-sketches/fractalNoise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fractalNoise.d.ts","sourceRoot":"","sources":["../../noise-sketches/fractalNoise.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,eAAO,MAAM,oBAAoB,4sGA+GhC,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

package/dist/noise-sketches/fractalNoise.js

@@ -0,0 +1,121 @@
+/**
+ * Fractal Noise - Code Mode Sketch
+ *
+ * This sketch implements Perlin FBM and Cellular noise rendering
+ * through the Code Mode p5-runtime. Uses N.* globals for all parameters.
+ *
+ * Original: client/src/components/noise-canvas-simple.tsx
+ */
+export const FRACTAL_NOISE_SKETCH = `
+// Fractal Noise - Code Mode Sketch
+// Uses N.* noise globals and standard p5-like functions
+
+function setup() {
+  // Set seeded random for reproducibility
+  randomSeed(N.seed);
+  noiseSeed(N.seed);
+  
+  // Set background color
+  background(N.bgR, N.bgG, N.bgB);
+  
+  // Noise rendering parameters
+  const adjustedScale = N.scale * (1 / N.zoom) * 0.05;
+  const cellSize = 4; // Fixed for quality
+  
+  // Generate cellular points if needed
+  const numPoints = Math.floor(20 + N.cellDensity * 180);
+  const cellPoints = [];
+  for (let i = 0; i < numPoints; i++) {
+    cellPoints.push([random(0, width), random(0, height)]);
+  }
+  
+  // Helper: Perlin FBM (Fractional Brownian Motion)
+  function perlinFBM(x, y, scale) {
+    let value = 0;
+    let amplitude = 1;
+    let frequency = 1;
+    let maxValue = 0;
+    
+    const oct = Math.min(N.octaves, 6); // Cap for performance
+    
+    for (let i = 0; i < oct; i++) {
+      value += noise(x * scale * frequency, y * scale * frequency) * amplitude;
+      maxValue += amplitude;
+      amplitude *= N.persistence;
+      frequency *= N.lacunarity;
+    }
+    
+    return value / maxValue;
+  }
+  
+  // Helper: Cellular noise (Worley)
+  function cellularNoise(x, y, points) {
+    let sampleX = x;
+    let sampleY = y;
+    
+    // Warp distortion if using warp mode
+    if (N.isWarp && N.cellDistortion > 0) {
+      const distortionAmount = N.cellDistortion * 100;
+      sampleX += noise(x * 0.01, y * 0.01) * distortionAmount;
+      sampleY += noise(y * 0.01, x * 0.01) * distortionAmount;
+    }
+    
+    // Find distances to closest points
+    let minDist = 999999;
+    let secondMinDist = 999999;
+    
+    for (let i = 0; i < points.length; i++) {
+      const px = points[i][0];
+      const py = points[i][1];
+      const dx = sampleX - px;
+      const dy = sampleY - py;
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      
+      if (dist < minDist) {
+        secondMinDist = minDist;
+        minDist = dist;
+      } else if (dist < secondMinDist) {
+        secondMinDist = dist;
+      }
+    }
+    
+    // Normalize distance
+    return Math.min(1.0, (secondMinDist - minDist) / 50);
+  }
+  
+  // Render the noise grid
+  noStroke();
+  
+  for (let y = 0; y < height; y += cellSize) {
+    for (let x = 0; x < width; x += cellSize) {
+      // Calculate Perlin value
+      const perlinValue = perlinFBM(x, y, adjustedScale);
+      
+      // Calculate final value based on blend mode
+      let finalValue = perlinValue;
+      
+      if (!N.isPerlinOnly) {
+        const cellValue = cellularNoise(x, y, cellPoints);
+        
+        if (N.isBlend) {
+          finalValue = perlinValue * cellValue;
+        } else if (N.isWarp) {
+          finalValue = (perlinValue + cellValue) / 2;
+        } else if (N.isInterleave) {
+          finalValue = (Math.floor(x / 20) + Math.floor(y / 20)) % 2 === 0
+            ? perlinValue
+            : cellValue;
+        }
+      }
+      
+      // Set opacity based on noise value
+      const alpha = map(finalValue, 0, 1, 0, 255);
+      
+      // Fill with noise color and calculated alpha
+      fill(N.noiseR, N.noiseG, N.noiseB, alpha);
+      rect(x, y, cellSize, cellSize);
+    }
+  }
+}
+`;
+export default FRACTAL_NOISE_SKETCH;

package/dist/noise-sketches/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Noise Sketches Index
+ *
+ * Exports all available noise sketch generators for the Code Mode runtime.
+ */
+import FRACTAL_NOISE_SKETCH from './fractalNoise';
+export type NoiseSketchName = 'fractalNoise';
+/**
+ * Get a noise sketch by name
+ */
+export declare function getNoiseSketch(name: NoiseSketchName): string;
+/**
+ * Check if a sketch name is valid
+ */
+export declare function isValidNoiseSketch(name: string): name is NoiseSketchName;
+/**
+ * Get list of all available noise sketch names
+ */
+export declare function getAvailableNoiseSketchNames(): NoiseSketchName[];
+export { FRACTAL_NOISE_SKETCH };
+//# sourceMappingURL=index.d.ts.map

package/dist/noise-sketches/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../noise-sketches/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,oBAAoB,MAAM,gBAAgB,CAAC;AAElD,MAAM,MAAM,eAAe,GAAG,cAAc,CAAC;AAM7C;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CAE5D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,eAAe,CAExE;AAED;;GAEG;AACH,wBAAgB,4BAA4B,IAAI,eAAe,EAAE,CAEhE;AAED,OAAO,EAAE,oBAAoB,EAAE,CAAC"}