@nexart/codemode-sdk 1.8.1 → 1.8.3

package/dist/execution-sandbox.js

@@ -1,207 +0,0 @@
-/**
- * NexArt Code Mode SDK - Execution Sandbox
- * Version: 1.6.0 (Protocol v1.2.0)
- *
- * ╔══════════════════════════════════════════════════════════════════════════╗
- * ║  EXECUTION BOUNDARY — HARD ENFORCEMENT                                   ║
- * ║                                                                          ║
- * ║  This module enforces determinism by blocking all external entropy       ║
- * ║  sources at RUNTIME, not just via static pattern scanning.               ║
- * ║                                                                          ║
- * ║  Blocked APIs (throw [Code Mode Protocol Error]):                        ║
- * ║  - Date, Date.now, Date.parse, new Date()                                ║
- * ║  - performance, performance.now                                          ║
- * ║  - process (Node.js)                                                     ║
- * ║  - navigator                                                             ║
- * ║  - globalThis                                                            ║
- * ║  - crypto.getRandomValues                                                ║
- * ║  - Math.random (use seeded random() instead)                             ║
- * ║  - setTimeout, setInterval, requestAnimationFrame                        ║
- * ║  - fetch, XMLHttpRequest                                                 ║
- * ║  - document, window                                                      ║
- * ║  - import, require                                                       ║
- * ║                                                                          ║
- * ║  All blocked symbols throw immediately on access — no silent undefined.  ║
- * ╚══════════════════════════════════════════════════════════════════════════╝
- */
-/**
- * Create a throwing stub for a forbidden API
- */
-function createForbiddenStub(name) {
-    const stub = function () {
-        throw new Error(`[Code Mode Protocol Error] Forbidden API: ${name}`);
-    };
-    return new Proxy(stub, {
-        get(_target, prop) {
-            if (prop === Symbol.toPrimitive || prop === 'toString' || prop === 'valueOf') {
-                return () => { throw new Error(`[Code Mode Protocol Error] Forbidden API: ${name}`); };
-            }
-            throw new Error(`[Code Mode Protocol Error] Forbidden API: ${name}.${String(prop)}`);
-        },
-        apply() {
-            throw new Error(`[Code Mode Protocol Error] Forbidden API: ${name}()`);
-        },
-        construct() {
-            throw new Error(`[Code Mode Protocol Error] Forbidden API: new ${name}()`);
-        },
-        set() {
-            throw new Error(`[Code Mode Protocol Error] Forbidden API: ${name} (assignment blocked)`);
-        },
-        has() {
-            return true;
-        }
-    });
-}
-/**
- * Create a frozen object that throws on any property access
- */
-function createForbiddenObject(name) {
-    return new Proxy({}, {
-        get(_target, prop) {
-            if (prop === Symbol.toPrimitive || prop === 'toString' || prop === 'valueOf') {
-                return () => { throw new Error(`[Code Mode Protocol Error] Forbidden API: ${name}`); };
-            }
-            throw new Error(`[Code Mode Protocol Error] Forbidden API: ${name}.${String(prop)}`);
-        },
-        set() {
-            throw new Error(`[Code Mode Protocol Error] Forbidden API: ${name} (assignment blocked)`);
-        },
-        has() {
-            return true;
-        },
-        apply() {
-            throw new Error(`[Code Mode Protocol Error] Forbidden API: ${name}()`);
-        },
-        construct() {
-            throw new Error(`[Code Mode Protocol Error] Forbidden API: new ${name}()`);
-        }
-    });
-}
-/**
- * Forbidden APIs - these are injected into the execution scope to override globals
- */
-export const FORBIDDEN_APIS = {
-    Date: createForbiddenStub('Date'),
-    performance: createForbiddenObject('performance'),
-    process: createForbiddenObject('process'),
-    navigator: createForbiddenObject('navigator'),
-    globalThis: createForbiddenObject('globalThis'),
-    crypto: createForbiddenObject('crypto'),
-    setTimeout: createForbiddenStub('setTimeout'),
-    setInterval: createForbiddenStub('setInterval'),
-    clearTimeout: createForbiddenStub('clearTimeout'),
-    clearInterval: createForbiddenStub('clearInterval'),
-    requestAnimationFrame: createForbiddenStub('requestAnimationFrame'),
-    cancelAnimationFrame: createForbiddenStub('cancelAnimationFrame'),
-    fetch: createForbiddenStub('fetch'),
-    XMLHttpRequest: createForbiddenStub('XMLHttpRequest'),
-    WebSocket: createForbiddenStub('WebSocket'),
-    document: createForbiddenObject('document'),
-    window: createForbiddenObject('window'),
-    self: createForbiddenObject('self'),
-    top: createForbiddenObject('top'),
-    parent: createForbiddenObject('parent'),
-    frames: createForbiddenObject('frames'),
-    location: createForbiddenObject('location'),
-    history: createForbiddenObject('history'),
-    localStorage: createForbiddenObject('localStorage'),
-    sessionStorage: createForbiddenObject('sessionStorage'),
-    indexedDB: createForbiddenObject('indexedDB'),
-    caches: createForbiddenObject('caches'),
-    Notification: createForbiddenStub('Notification'),
-    Worker: createForbiddenStub('Worker'),
-    SharedWorker: createForbiddenStub('SharedWorker'),
-    ServiceWorker: createForbiddenObject('ServiceWorker'),
-    Blob: createForbiddenStub('Blob'),
-    File: createForbiddenStub('File'),
-    FileReader: createForbiddenStub('FileReader'),
-    URL: createForbiddenStub('URL'),
-    URLSearchParams: createForbiddenStub('URLSearchParams'),
-    Headers: createForbiddenStub('Headers'),
-    Request: createForbiddenStub('Request'),
-    Response: createForbiddenStub('Response'),
-    EventSource: createForbiddenStub('EventSource'),
-    Image: createForbiddenStub('Image'),
-    Audio: createForbiddenStub('Audio'),
-    Video: createForbiddenStub('Video'),
-    eval: createForbiddenStub('eval'),
-    Function: createForbiddenStub('Function'),
-};
-/**
- * Create a safe Math object with random() blocked
- */
-export function createSafeMath() {
-    const safeMath = Object.create(Math);
-    Object.defineProperty(safeMath, 'random', {
-        get() {
-            throw new Error('[Code Mode Protocol Error] Forbidden API: Math.random() — use random() instead (seeded)');
-        },
-        configurable: false,
-        enumerable: true
-    });
-    return Object.freeze(safeMath);
-}
-/**
- * List of all forbidden API names for documentation
- */
-export const FORBIDDEN_API_NAMES = Object.keys(FORBIDDEN_APIS);
-/**
- * Build the complete sandbox context for sketch execution.
- * This includes the p5 runtime plus all forbidden API stubs.
- */
-export function buildSandboxContext(p5Runtime) {
-    const safeMath = createSafeMath();
-    const context = {
-        ...FORBIDDEN_APIS,
-        Math: safeMath,
-    };
-    for (const key of Object.keys(p5Runtime)) {
-        context[key] = p5Runtime[key];
-    }
-    return context;
-}
-/**
- * Create a sandboxed function that executes user code with blocked globals.
- *
- * The function is constructed with:
- * 1. All forbidden APIs as explicit parameters (override globals)
- * 2. The p5 runtime as explicit parameters
- * 3. A `with(context)` wrapper for additional safety
- */
-export function createSandboxedExecutor(code, additionalParams = []) {
-    const forbiddenParamNames = Object.keys(FORBIDDEN_APIS);
-    const allParams = [
-        'context',
-        'Math',
-        ...forbiddenParamNames,
-        ...additionalParams
-    ];
-    const wrappedCode = `
-    "use strict";
-    with(context) {
-      ${code}
-    }
-  `;
-    return new Function(...allParams, wrappedCode);
-}
-/**
- * Execute user code in a sandboxed environment.
- *
- * @param code - The user sketch code to execute
- * @param p5Runtime - The p5-like runtime object
- * @param additionalContext - Additional context variables (frameCount, t, etc.)
- */
-export function executeSandboxed(code, p5Runtime, additionalContext = {}) {
-    const safeMath = createSafeMath();
-    const fullContext = {
-        ...p5Runtime,
-        ...additionalContext,
-        Math: safeMath,
-        ...FORBIDDEN_APIS,
-    };
-    const forbiddenValues = Object.keys(FORBIDDEN_APIS).map(key => FORBIDDEN_APIS[key]);
-    const additionalParamNames = Object.keys(additionalContext);
-    const additionalValues = Object.values(additionalContext);
-    const executor = createSandboxedExecutor(code, additionalParamNames);
-    executor(fullContext, safeMath, ...forbiddenValues, ...additionalValues);
-}

package/dist/index.d.ts

@@ -1,31 +0,0 @@
-/**
- * NexArt Code Mode Runtime SDK - App Integration Layer
- *
- * ╔══════════════════════════════════════════════════════════════════════════╗
- * ║  LOCAL SDK WRAPPER                                                       ║
- * ║                                                                          ║
- * ║  This file re-exports the core runtime from @nexart/codemode-sdk (npm)   ║
- * ║  and adds app-specific integrations (SoundArt, Noise, etc.)              ║
- * ║                                                                          ║
- * ║  For core Code Mode: import from '@nexart/codemode-sdk'                  ║
- * ║  For app integrations: import from 'sdk/codemode'                        ║
- * ╚══════════════════════════════════════════════════════════════════════════╝
- */
-export { executeCodeMode, validateCodeModeSource, DEFAULT_CONFIG, PROTOCOL_IDENTITY, } from '@nexart/codemode-sdk';
-export type { ExecuteCodeModeInput, ExecuteCodeModeResult, ProtocolMetadata, RenderResult, TimeVariables, } from '@nexart/codemode-sdk';
-export { createP5Runtime, injectTimeVariables, injectProtocolVariables, createProtocolVAR } from './p5-runtime';
-export type { P5Runtime, P5RuntimeConfig } from './p5-runtime';
-export { createEngine } from './engine';
-export type { Engine, EngineConfig, RunOptions, ProgressInfo, RenderMode, } from './types';
-export { DEFAULT_CONFIG as LOCAL_DEFAULT_CONFIG } from './types';
-export { renderSoundArtViaCodeMode, canRenderViaCodeMode, getCodeModeAvailableStyles, type SoundArtEngineConfig, type SoundArtRenderOptions, type SoundArtRenderResult, type SoundArtMetadata, } from './soundart-engine';
-export { type SoundSnapshot, type SoundFeatures, createSoundSnapshot, createEmptySoundSnapshot, freezeSoundSnapshot, } from '../../shared/soundSnapshot';
-export { injectSoundGlobals, createSoundGlobals, createEmptySoundGlobals, generateSoundPalette, inferGenreProfile, createSoundHelpers, type SoundGlobals, type GenreProfile, } from './sound-bridge';
-export { getSoundArtSketch, getAvailableSoundArtSketches, isSoundArtSketchAvailable, type SoundArtSketchName, } from './soundart-sketches';
-export { renderNoiseViaCodeMode, compileNoiseSystem, canRenderNoiseViaCodeMode, type NoiseEngineConfig, type NoiseRenderOptions, type NoiseRenderResult, type NoiseMetadata, } from './noise-engine';
-export { type NoiseSnapshot, type NoiseParams, type NoiseBlendMode, createNoiseSnapshot, validateNoiseSnapshot, } from '../../shared/noiseSnapshot';
-export { createNoiseGlobals, injectNoiseGlobals, type NoiseGlobals, } from './noise-bridge';
-export { getNoiseSketch, getAvailableNoiseSketchNames, isValidNoiseSketch, type NoiseSketchName, } from './noise-sketches';
-export { registerBuilderManifest } from './builder-manifest';
-export type { NexArtBuilderManifest } from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,cAAc,EACd,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EACV,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EAChB,YAAY,EACZ,aAAa,GACd,MAAM,sBAAsB,CAAC;AAO9B,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAChH,YAAY,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAK/D,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,YAAY,EACV,MAAM,EACN,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,UAAU,GACX,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,cAAc,IAAI,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAGjE,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;AAG7B,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;AAkB1B,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAE7D,YAAY,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -1,63 +0,0 @@
-/**
- * NexArt Code Mode Runtime SDK - App Integration Layer
- *
- * ╔══════════════════════════════════════════════════════════════════════════╗
- * ║  LOCAL SDK WRAPPER                                                       ║
- * ║                                                                          ║
- * ║  This file re-exports the core runtime from @nexart/codemode-sdk (npm)   ║
- * ║  and adds app-specific integrations (SoundArt, Noise, etc.)              ║
- * ║                                                                          ║
- * ║  For core Code Mode: import from '@nexart/codemode-sdk'                  ║
- * ║  For app integrations: import from 'sdk/codemode'                        ║
- * ╚══════════════════════════════════════════════════════════════════════════╝
- */
-// ═══════════════════════════════════════════════════════════════════════════
-// CORE RUNTIME - Re-exported from @nexart/codemode-sdk (npm package)
-// ═══════════════════════════════════════════════════════════════════════════
-export { executeCodeMode, validateCodeModeSource, DEFAULT_CONFIG, PROTOCOL_IDENTITY, } from '@nexart/codemode-sdk';
-// ═══════════════════════════════════════════════════════════════════════════
-// LOCAL P5 RUNTIME - Used by app integrations (SoundArt, Noise)
-// The npm package also exports createP5Runtime, but we keep local for 
-// app-specific extensions that need tighter integration
-// ═══════════════════════════════════════════════════════════════════════════
-export { createP5Runtime, injectTimeVariables, injectProtocolVariables, createProtocolVAR } from './p5-runtime';
-// ═══════════════════════════════════════════════════════════════════════════
-// LEGACY ENGINE API (kept for backwards compatibility)
-// ═══════════════════════════════════════════════════════════════════════════
-export { createEngine } from './engine';
-export { DEFAULT_CONFIG as LOCAL_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';
-// 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';
-// ═══════════════════════════════════════════════════════════════════════════
-// BUILDER MANIFEST (v1.6.0) — Passive Attribution
-// 
-// The Builder Manifest is a declaration of intent, not a capability.
-// The SDK does not expose any API to read or inspect manifests.
-// 
-// This is:
-//   - Declarative (write-only)
-//   - Optional (no errors if missing)
-//   - Non-enforced (no validation)
-//   - Non-rewarding (no incentives)
-// 
-// There is NO SDK API to read manifests, NO validation, NO attribution
-// logic, and NO tracking. Execution behavior is identical with or without
-// a manifest registered.
-// ═══════════════════════════════════════════════════════════════════════════
-export { registerBuilderManifest } from './builder-manifest';
-// ═══════════════════════════════════════════════════════════════════════════
-// EXECUTION BOUNDARY (Internal — Not Exported)
-// 
-// The execution sandbox blocks all external entropy sources at runtime.
-// See EXECUTION_BOUNDARY.md for details.
-// ═══════════════════════════════════════════════════════════════════════════
-// Note: FORBIDDEN_APIS and createSafeMath are NOT exported.
-// They are internal implementation details used by the engines.

package/dist/loop-engine.d.ts

@@ -1,22 +0,0 @@
-/**
- * NexArt Code Mode Runtime SDK - Loop Engine
- * Protocol: v1.2.0 (Phase 3) — HARD ENFORCEMENT
- *
- * Loop mode renderer: frame-authoritative, stateless execution.
- * - Executes setup() once
- * - Executes draw() once per frame
- * - Clears canvas before each frame (transparent)
- * - Resets blend mode to NORMAL before each frame
- * - Injects normalized time variables
- * - No canvas persistence between frames
- *
- * 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;
-export declare function runLoopMode(config: EngineConfig, options: RunOptions): Promise<void>;
-//# sourceMappingURL=loop-engine.d.ts.map

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

@@ -1 +0,0 @@
-{"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

@@ -1,229 +0,0 @@
-/**
- * NexArt Code Mode Runtime SDK - Loop Engine
- * Protocol: v1.2.0 (Phase 3) — HARD ENFORCEMENT
- *
- * Loop mode renderer: frame-authoritative, stateless execution.
- * - Executes setup() once
- * - Executes draw() once per frame
- * - Clears canvas before each frame (transparent)
- * - Resets blend mode to NORMAL before each frame
- * - Injects normalized time variables
- * - No canvas persistence between frames
- *
- * 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;
-}
-export async function runLoopMode(config, options) {
-    const { code, seed, vars, onPreview, onProgress, onComplete, onError } = options;
-    const width = config.width ?? DEFAULT_CONFIG.width;
-    const height = config.height ?? DEFAULT_CONFIG.height;
-    const duration = Math.max(DEFAULT_CONFIG.minDuration, Math.min(DEFAULT_CONFIG.maxDuration, config.duration ?? DEFAULT_CONFIG.duration));
-    const fps = config.fps ?? DEFAULT_CONFIG.fps;
-    const totalFrames = Math.floor(duration * fps);
-    isCancelled = false;
-    try {
-        onProgress?.({
-            phase: 'setup',
-            percent: 0,
-            message: 'Initializing canvas...',
-        });
-        // Create canvas
-        const canvas = document.createElement('canvas');
-        canvas.width = width;
-        canvas.height = height;
-        // Create p5 runtime with optional seed for determinism
-        const p = createP5Runtime(canvas, width, height, { seed });
-        // Inject protocol variables (VAR[0..9])
-        injectProtocolVariables(p, vars);
-        // Validate code
-        const hasDrawFunction = /function\s+draw\s*\(\s*\)/.test(code);
-        if (!hasDrawFunction) {
-            throw new Error('Loop Mode requires a draw() function.');
-        }
-        const forbiddenPatterns = [
-            { pattern: /noLoop\s*\(\s*\)/, name: 'noLoop()' },
-            { pattern: /setTimeout\s*\(/, name: 'setTimeout' },
-            { pattern: /setInterval\s*\(/, name: 'setInterval' },
-            { pattern: /requestAnimationFrame\s*\(/, name: 'requestAnimationFrame' },
-        ];
-        for (const { pattern, name } of forbiddenPatterns) {
-            if (pattern.test(code)) {
-                throw new Error(`Forbidden function in Loop Mode: ${name}`);
-            }
-        }
-        onProgress?.({
-            phase: 'setup',
-            percent: 5,
-            message: 'Parsing code...',
-        });
-        // Extract setup() and draw() functions
-        const setupMatch = code.match(/function\s+setup\s*\(\s*\)\s*\{([\s\S]*?)\}(?=\s*function|\s*$)/);
-        const drawMatch = code.match(/function\s+draw\s*\(\s*\)\s*\{([\s\S]*?)\}(?=\s*function|\s*$)/);
-        const setupCode = setupMatch ? setupMatch[1].trim() : '';
-        const drawCode = drawMatch ? drawMatch[1].trim() : '';
-        if (!drawCode) {
-            throw new Error('Loop Mode requires a draw() function with content.');
-        }
-        // Inject totalFrames into runtime
-        p.totalFrames = totalFrames;
-        // 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, totalFrames, and sandboxed context
-        wrappedSetup(p, 0, 0, 0, 0, p.VAR, totalFrames, safeMath, ...forbiddenValues);
-        // Capture frames
-        const frames = [];
-        onProgress?.({
-            phase: 'rendering',
-            frame: 0,
-            totalFrames,
-            percent: 10,
-            message: `Rendering frames (0/${totalFrames})...`,
-        });
-        for (let frame = 0; frame < totalFrames; frame++) {
-            if (isCancelled) {
-                throw new Error('Rendering cancelled');
-            }
-            // Calculate normalized time variables
-            // t = frame / totalFrames (range [0, 1))
-            const t = frame / totalFrames;
-            const time = t * duration;
-            // Update p5 runtime frameCount
-            p.frameCount = frame;
-            // CRITICAL: Reset canvas state before each draw() call
-            // This enforces stateless, frame-authoritative rendering
-            // 1. Clear canvas (transparent)
-            p.clear();
-            // 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, 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');
-            });
-            frames.push(blob);
-            // Provide preview on first frame
-            if (frame === 0) {
-                onPreview?.(canvas);
-            }
-            // Update progress
-            const percent = 10 + Math.floor((frame / totalFrames) * 60);
-            onProgress?.({
-                phase: 'rendering',
-                frame: frame + 1,
-                totalFrames,
-                percent,
-                message: `Rendering frames (${frame + 1}/${totalFrames})...`,
-            });
-            // Yield to prevent blocking UI
-            if (frame % 10 === 0) {
-                await new Promise(resolve => setTimeout(resolve, 0));
-            }
-        }
-        onProgress?.({
-            phase: 'encoding',
-            frame: totalFrames,
-            totalFrames,
-            percent: 70,
-            message: 'Encoding video...',
-        });
-        // Encode to video (MP4)
-        const videoBlob = await encodeFramesToMP4(frames, fps, width, height, (progress) => {
-            const percent = 70 + Math.floor(progress * 30);
-            onProgress?.({
-                phase: 'encoding',
-                frame: totalFrames,
-                totalFrames,
-                percent,
-                message: `Encoding video (${Math.floor(progress * 100)}%)...`,
-            });
-        });
-        onProgress?.({
-            phase: 'complete',
-            frame: totalFrames,
-            totalFrames,
-            percent: 100,
-            message: 'Complete',
-        });
-        const result = {
-            type: 'video',
-            blob: videoBlob,
-            frames: totalFrames,
-            duration,
-        };
-        onComplete(result);
-    }
-    catch (error) {
-        const err = error instanceof Error ? error : new Error(String(error));
-        onError?.(err);
-    }
-}
-/**
- * Encode frames to MP4 video
- * Uses server-side encoding endpoint for cross-browser reliability
- */
-async function encodeFramesToMP4(frames, fps, width, height, onProgress) {
-    // Convert frames to base64 for server transport
-    const frameDataUrls = [];
-    for (let i = 0; i < frames.length; i++) {
-        const reader = new FileReader();
-        const dataUrl = await new Promise((resolve, reject) => {
-            reader.onload = () => resolve(reader.result);
-            reader.onerror = reject;
-            reader.readAsDataURL(frames[i]);
-        });
-        frameDataUrls.push(dataUrl);
-        onProgress?.(i / frames.length * 0.3);
-    }
-    // Send to server for encoding
-    const response = await fetch('/api/encode-loop', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            frames: frameDataUrls,
-            fps,
-            width,
-            height,
-        }),
-    });
-    if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Video encoding failed: ${errorText}`);
-    }
-    onProgress?.(0.8);
-    const data = await response.json();
-    if (!data.video) {
-        throw new Error('No video data returned from encoder');
-    }
-    // Convert base64 to blob
-    const binaryString = atob(data.video.split(',')[1] || data.video);
-    const bytes = new Uint8Array(binaryString.length);
-    for (let i = 0; i < binaryString.length; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-    }
-    onProgress?.(1);
-    return new Blob([bytes], { type: 'video/mp4' });
-}

package/dist/noise-bridge.d.ts

@@ -1,44 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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"}