@nexart/codemode-sdk 1.8.0 → 1.8.2

package/dist/builder-manifest.js

@@ -1,97 +0,0 @@
-/**
- * NexArt Code Mode SDK - Builder Manifest
- * Version: 1.6.0 (Protocol v1.2.0)
- *
- * ╔══════════════════════════════════════════════════════════════════════════╗
- * ║  BUILDER MANIFEST — PASSIVE ATTRIBUTION (WRITE-ONLY)                     ║
- * ║                                                                          ║
- * ║  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, no read API exposed)                       ║
- * ║    - Optional (no errors if missing or invalid)                          ║
- * ║    - Non-enforced (no validation logic)                                  ║
- * ║    - Non-rewarding (no incentives, no tracking)                          ║
- * ║                                                                          ║
- * ║  There is:                                                               ║
- * ║    - No SDK API to read manifests                                        ║
- * ║    - No validation                                                       ║
- * ║    - No attribution logic                                                ║
- * ║    - No tracking, analytics, or network calls                            ║
- * ║                                                                          ║
- * ║  Execution behavior is identical with or without a manifest.             ║
- * ╚══════════════════════════════════════════════════════════════════════════╝
- */
-/** Internal storage - not accessible to SDK consumers */
-let currentManifest = null;
-/**
- * Register a builder manifest for attribution.
- *
- * This is optional and does not affect execution behavior.
- * The manifest is stored in-memory only and is not:
- * - Serialized to disk
- * - Sent over the network
- * - Logged to console
- * - Used for validation or enforcement
- *
- * @param manifest - Optional builder manifest. Pass undefined to clear.
- *
- * @example
- * ```typescript
- * import { registerBuilderManifest } from "@nexart/codemode-sdk";
- *
- * registerBuilderManifest({
- *   protocol: "nexart",
- *   manifestVersion: "0.1",
- *   app: { name: "My App", url: "https://myapp.com" }
- * });
- * ```
- */
-export function registerBuilderManifest(manifest) {
-    if (!manifest) {
-        currentManifest = null;
-        return;
-    }
-    if (manifest.protocol !== 'nexart') {
-        currentManifest = null;
-        return;
-    }
-    if (typeof manifest.manifestVersion !== 'string') {
-        currentManifest = null;
-        return;
-    }
-    currentManifest = manifest;
-}
-/**
- * Get the currently registered builder manifest.
- *
- * ╔══════════════════════════════════════════════════════════════════════════╗
- * ║  INTERNAL FUNCTION — NOT EXPORTED TO SDK CONSUMERS                       ║
- * ║                                                                          ║
- * ║  This function exists only for internal SDK execution context.           ║
- * ║  It is NOT part of the public API and must NOT be exported from index.   ║
- * ║  Runtime code and sketch code cannot access this function.               ║
- * ╚══════════════════════════════════════════════════════════════════════════╝
- *
- * @internal
- */
-export function getBuilderManifest() {
-    return currentManifest;
-}
-/**
- * Clear the registered builder manifest.
- *
- * ╔══════════════════════════════════════════════════════════════════════════╗
- * ║  INTERNAL FUNCTION — NOT EXPORTED TO SDK CONSUMERS                       ║
- * ║                                                                          ║
- * ║  This function exists only for internal SDK execution context.           ║
- * ║  It is NOT part of the public API and must NOT be exported from index.   ║
- * ║  Runtime code and sketch code cannot access this function.               ║
- * ╚══════════════════════════════════════════════════════════════════════════╝
- *
- * @internal
- */
-export function clearBuilderManifest() {
-    currentManifest = null;
-}

package/dist/core-index.d.ts

@@ -1,21 +0,0 @@
-/**
- * @nexart/codemode-sdk v1.4.0 — Core Exports
- *
- * Canonical execution engine for NexArt Code Mode.
- * This is the single source of truth for Code Mode semantics.
- *
- * Protocol: v1.2.0 (Phase 3)
- * Enforcement: HARD
- */
-export { executeCodeMode, validateCodeModeSource, } from './execute';
-export { type RenderMode, type TimeVariables, type ProtocolMetadata, type EngineConfig, type RenderResult, type RunOptions, type ProgressInfo, type Engine, type ExecuteCodeModeInput, type ExecuteCodeModeResult, PROTOCOL_IDENTITY, DEFAULT_VARS, DEFAULT_CONFIG, } from './types';
-export { createP5Runtime, injectTimeVariables, createProtocolVAR, VAR_COUNT, VAR_MIN, VAR_MAX, CODE_MODE_PROTOCOL_VERSION, CODE_MODE_PROTOCOL_PHASE, CODE_MODE_ENFORCEMENT, type P5Runtime, type P5RuntimeConfig, } from './p5-runtime';
-export { runStaticMode, } from './static-engine';
-export { runLoopMode, cancelLoopMode, } from './loop-engine';
-export { createEngine, } from './engine';
-/**
- * SDK Identity
- */
-export declare const SDK_VERSION = "1.8.0";
-export declare const SDK_NAME = "@nexart/codemode-sdk";
-//# sourceMappingURL=core-index.d.ts.map

package/dist/core-index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"core-index.d.ts","sourceRoot":"","sources":["../core-index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EACL,eAAe,EACf,sBAAsB,GACvB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,MAAM,EACX,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,iBAAiB,EACjB,YAAY,EACZ,cAAc,GACf,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,iBAAiB,EACjB,SAAS,EACT,OAAO,EACP,OAAO,EACP,0BAA0B,EAC1B,wBAAwB,EACxB,qBAAqB,EACrB,KAAK,SAAS,EACd,KAAK,eAAe,GACrB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,aAAa,GACd,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,WAAW,EACX,cAAc,GACf,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,YAAY,GACb,MAAM,UAAU,CAAC;AAElB;;GAEG;AACH,eAAO,MAAM,WAAW,UAAU,CAAC;AACnC,eAAO,MAAM,QAAQ,yBAAyB,CAAC"}

package/dist/core-index.js

@@ -1,26 +0,0 @@
-/**
- * @nexart/codemode-sdk v1.4.0 — Core Exports
- *
- * Canonical execution engine for NexArt Code Mode.
- * This is the single source of truth for Code Mode semantics.
- *
- * Protocol: v1.2.0 (Phase 3)
- * Enforcement: HARD
- */
-// Core execution
-export { executeCodeMode, validateCodeModeSource, } from './execute';
-// Protocol types
-export { PROTOCOL_IDENTITY, DEFAULT_VARS, DEFAULT_CONFIG, } from './types';
-// Runtime
-export { createP5Runtime, injectTimeVariables, createProtocolVAR, VAR_COUNT, VAR_MIN, VAR_MAX, CODE_MODE_PROTOCOL_VERSION, CODE_MODE_PROTOCOL_PHASE, CODE_MODE_ENFORCEMENT, } from './p5-runtime';
-// Static engine
-export { runStaticMode, } from './static-engine';
-// Loop engine
-export { runLoopMode, cancelLoopMode, } from './loop-engine';
-// Engine utilities
-export { createEngine, } from './engine';
-/**
- * SDK Identity
- */
-export const SDK_VERSION = '1.8.0';
-export const SDK_NAME = '@nexart/codemode-sdk';

package/dist/engine.d.ts

@@ -1,24 +0,0 @@
-/**
- * NexArt Code Mode Runtime SDK
- * Version: 0.1.0
- *
- * Main entry point for the Code Mode runtime engine.
- *
- * Usage:
- *   const engine = createEngine({ mode: 'static' });
- *   engine.run({
- *     code: 'function setup() { background(255); ellipse(width/2, height/2, 100); }',
- *     onComplete: (result) => console.log(result.blob)
- *   });
- */
-import type { Engine, EngineConfig } from './types';
-/**
- * Create a NexArt Code Mode rendering engine.
- *
- * @param config - Engine configuration
- * @returns Engine instance
- */
-export declare function createEngine(config: EngineConfig): Engine;
-export type { Engine, EngineConfig, RunOptions, RenderResult, ProgressInfo } from './types';
-export { DEFAULT_CONFIG } from './types';
-//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAc,MAAM,SAAS,CAAC;AAKhE;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CA+CzD;AAGD,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC5F,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC"}

package/dist/engine.js

@@ -1,67 +0,0 @@
-/**
- * NexArt Code Mode Runtime SDK
- * Version: 0.1.0
- *
- * Main entry point for the Code Mode runtime engine.
- *
- * Usage:
- *   const engine = createEngine({ mode: 'static' });
- *   engine.run({
- *     code: 'function setup() { background(255); ellipse(width/2, height/2, 100); }',
- *     onComplete: (result) => console.log(result.blob)
- *   });
- */
-import { DEFAULT_CONFIG } from './types';
-import { runStaticMode } from './static-engine';
-import { runLoopMode, cancelLoopMode } from './loop-engine';
-/**
- * Create a NexArt Code Mode rendering engine.
- *
- * @param config - Engine configuration
- * @returns Engine instance
- */
-export function createEngine(config) {
-    const resolvedConfig = {
-        mode: config.mode,
-        width: config.width ?? DEFAULT_CONFIG.width,
-        height: config.height ?? DEFAULT_CONFIG.height,
-        duration: config.duration ?? DEFAULT_CONFIG.duration,
-        fps: config.fps ?? DEFAULT_CONFIG.fps,
-    };
-    let isRunning = false;
-    const run = async (options) => {
-        if (isRunning) {
-            throw new Error('Engine is already running. Call stop() first.');
-        }
-        isRunning = true;
-        try {
-            if (resolvedConfig.mode === 'static') {
-                await runStaticMode(resolvedConfig, options);
-            }
-            else if (resolvedConfig.mode === 'loop') {
-                await runLoopMode(resolvedConfig, options);
-            }
-            else {
-                throw new Error(`Unknown mode: ${resolvedConfig.mode}`);
-            }
-        }
-        finally {
-            isRunning = false;
-        }
-    };
-    const stop = () => {
-        if (resolvedConfig.mode === 'loop') {
-            cancelLoopMode();
-        }
-        isRunning = false;
-    };
-    const getConfig = () => {
-        return { ...resolvedConfig };
-    };
-    return {
-        run,
-        stop,
-        getConfig,
-    };
-}
-export { DEFAULT_CONFIG } from './types';

package/dist/entry/browser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../entry/browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,YAAY,EACV,UAAU,EACV,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,MAAM,EACN,aAAa,EACb,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,cAAc,GACf,MAAM,UAAU,CAAC;AAKlB,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAK9B,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,uBAAuB,EACvB,iBAAiB,EACjB,SAAS,EACT,OAAO,EACP,OAAO,EACP,0BAA0B,EAC1B,wBAAwB,EACxB,qBAAqB,GACtB,MAAM,eAAe,CAAC;AAEvB,YAAY,EACV,SAAS,EACT,eAAe,GAChB,MAAM,eAAe,CAAC;AAKvB,OAAO,EACL,WAAW,EACX,cAAc,GACf,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EACL,sBAAsB,GACvB,MAAM,YAAY,CAAC;AAKpB,OAAO,EACL,YAAY,GACb,MAAM,WAAW,CAAC;AAKnB,OAAO,EACL,uBAAuB,GACxB,MAAM,qBAAqB,CAAC;AAK7B,OAAO,EACL,aAAa,EACb,aAAa,EACb,eAAe,GAChB,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,cAAc,EACd,YAAY,EACZ,aAAa,IAAI,iBAAiB,GACnC,MAAM,YAAY,CAAC;AAKpB,eAAO,MAAM,WAAW,UAAU,CAAC;AACnC,eAAO,MAAM,QAAQ,yBAAyB,CAAC;AAC/C,eAAO,MAAM,SAAS,YAAY,CAAC;AAEnC;;;;;;;;;;;GAWG"}

package/dist/entry/node.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../entry/node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,cAAc,WAAW,CAAC;AAK1B,OAAO,EACL,aAAa,GACd,MAAM,kBAAkB,CAAC;AAK1B,OAAO,EACL,eAAe,GAChB,MAAM,YAAY,CAAC;AAKpB,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAClD,eAAO,MAAM,SAAS,SAAS,CAAC"}

package/dist/execute.d.ts

@@ -1,46 +0,0 @@
-/**
- * NexArt Code Mode Runtime SDK - Canonical Execution Entry Point
- *
- * ╔══════════════════════════════════════════════════════════════════════════╗
- * ║  CODE MODE PROTOCOL v1.2.0 (Phase 3) — CANONICAL ENTRY POINT             ║
- * ║                                                                          ║
- * ║  This is the ONLY official way to execute Code Mode.                     ║
- * ║  All implementations (NexArt, ByX, external) MUST use this function.     ║
- * ║                                                                          ║
- * ║  Authority: @nexart/codemode-sdk                                         ║
- * ╚══════════════════════════════════════════════════════════════════════════╝
- */
-import { ExecuteCodeModeInput, ExecuteCodeModeResult } from './types';
-/**
- * executeCodeMode — Canonical Code Mode Execution Entry Point
- *
- * This is the ONLY official way to execute Code Mode.
- * All implementations MUST use this function.
- *
- * @param input - Execution parameters
- * @returns Promise<ExecuteCodeModeResult> - Execution result with protocol metadata
- *
- * @example
- * ```typescript
- * const result = await executeCodeMode({
- *   source: `function setup() { background(255); ellipse(width/2, height/2, 100); }`,
- *   width: 1950,
- *   height: 2400,
- *   seed: 12345,
- *   vars: [50, 75, 0, 0, 0, 0, 0, 0, 0, 0],
- *   mode: 'static'
- * });
- *
- * console.log(result.metadata.protocolVersion); // '1.2.0'
- * console.log(result.image); // PNG Blob
- * ```
- */
-export declare function executeCodeMode(input: ExecuteCodeModeInput): Promise<ExecuteCodeModeResult>;
-/**
- * Validate code without executing
- */
-export declare function validateCodeModeSource(source: string, mode: 'static' | 'loop'): {
-    valid: boolean;
-    errors: string[];
-};
-//# sourceMappingURL=execute.d.ts.map

package/dist/execute.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../execute.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EAMtB,MAAM,SAAS,CAAC;AAuNjB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,qBAAqB,CAAC,CAmChC;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAuCpH"}

package/dist/execute.js

@@ -1,283 +0,0 @@
-/**
- * NexArt Code Mode Runtime SDK - Canonical Execution Entry Point
- *
- * ╔══════════════════════════════════════════════════════════════════════════╗
- * ║  CODE MODE PROTOCOL v1.2.0 (Phase 3) — CANONICAL ENTRY POINT             ║
- * ║                                                                          ║
- * ║  This is the ONLY official way to execute Code Mode.                     ║
- * ║  All implementations (NexArt, ByX, external) MUST use this function.     ║
- * ║                                                                          ║
- * ║  Authority: @nexart/codemode-sdk                                         ║
- * ╚══════════════════════════════════════════════════════════════════════════╝
- */
-import { runStaticMode } from './static-engine';
-import { runLoopMode } from './loop-engine';
-import { PROTOCOL_IDENTITY, DEFAULT_CONFIG, } from './types';
-import { getBuilderManifest } from './builder-manifest';
-/**
- * Validate and normalize VAR array to 10 elements.
- *
- * Rules (SDK v1.0.2, Protocol v1.0.0):
- * - VAR is OPTIONAL: omit or pass [] for empty (defaults to all zeros)
- * - VAR input length MUST be 0-10 elements (protocol error if > 10)
- * - VAR values MUST be finite numbers (protocol error if not)
- * - VAR values MUST be in range 0-100 (protocol error if out of range, NO clamping)
- * - VAR is read-only inside sketches
- * - Output is ALWAYS 10 elements (padded with zeros) for protocol consistency
- */
-function normalizeVars(vars) {
-    if (!vars || !Array.isArray(vars)) {
-        console.log('[CodeMode] No vars provided, using defaults [0,0,0,0,0,0,0,0,0,0]');
-        return [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-    }
-    if (vars.length > 10) {
-        throw new Error(`[Code Mode Protocol Error] VAR array must have at most 10 elements, got ${vars.length}`);
-    }
-    const result = [];
-    for (let i = 0; i < vars.length; i++) {
-        const v = vars[i];
-        if (typeof v !== 'number' || !Number.isFinite(v)) {
-            throw new Error(`[Code Mode Protocol Error] VAR[${i}] must be a finite number, got ${typeof v === 'number' ? v : typeof v}`);
-        }
-        if (v < 0 || v > 100) {
-            throw new Error(`[Code Mode Protocol Error] VAR[${i}] = ${v} is out of range. Values must be 0-100.`);
-        }
-        result.push(v);
-    }
-    // Pad with zeros to always have 10 elements for protocol consistency
-    while (result.length < 10) {
-        result.push(0);
-    }
-    return result;
-}
-/**
- * Validate execution input
- */
-function validateInput(input) {
-    if (!input.source || typeof input.source !== 'string') {
-        throw new Error('[Code Mode Protocol Error] source is required and must be a string');
-    }
-    if (typeof input.width !== 'number' || input.width <= 0) {
-        throw new Error('[Code Mode Protocol Error] width must be a positive number');
-    }
-    if (typeof input.height !== 'number' || input.height <= 0) {
-        throw new Error('[Code Mode Protocol Error] height must be a positive number');
-    }
-    if (typeof input.seed !== 'number') {
-        throw new Error('[Code Mode Protocol Error] seed is required and must be a number');
-    }
-    if (input.mode !== 'static' && input.mode !== 'loop') {
-        throw new Error('[Code Mode Protocol Error] mode must be "static" or "loop"');
-    }
-    if (input.mode === 'loop') {
-        if (typeof input.totalFrames !== 'number' || input.totalFrames <= 0) {
-            throw new Error('[Code Mode Protocol Error] totalFrames is required for loop mode and must be a positive number');
-        }
-    }
-    // Validate forbidden patterns per CODE_MODE_PROTOCOL.md
-    const forbiddenPatterns = [
-        // Async timing (breaks determinism)
-        { pattern: /setTimeout\s*\(/, name: 'setTimeout' },
-        { pattern: /setInterval\s*\(/, name: 'setInterval' },
-        { pattern: /requestAnimationFrame\s*\(/, name: 'requestAnimationFrame' },
-        // Time-based entropy (breaks determinism)
-        { pattern: /Date\.now\s*\(/, name: 'Date.now() — use time variable instead' },
-        { pattern: /new\s+Date\s*\(/, name: 'new Date() — use time variable instead' },
-        // Unseeded random (use random() instead)
-        { pattern: /Math\.random\s*\(/, name: 'Math.random() — use random() instead (seeded)' },
-        // External IO (breaks determinism)
-        { pattern: /fetch\s*\(/, name: 'fetch() — external IO forbidden' },
-        { pattern: /XMLHttpRequest/, name: 'XMLHttpRequest — external IO forbidden' },
-        // Canvas is pre-initialized
-        { pattern: /createCanvas\s*\(/, name: 'createCanvas() — canvas is pre-initialized' },
-        // DOM manipulation forbidden
-        { pattern: /document\./, name: 'DOM access — document.* forbidden' },
-        { pattern: /window\./, name: 'DOM access — window.* forbidden' },
-        // External imports forbidden
-        { pattern: /\bimport\s+/, name: 'import — external imports forbidden' },
-        { pattern: /\brequire\s*\(/, name: 'require() — external imports forbidden' },
-    ];
-    for (const { pattern, name } of forbiddenPatterns) {
-        if (pattern.test(input.source)) {
-            throw new Error(`[Code Mode Protocol Error] Forbidden pattern: ${name}`);
-        }
-    }
-    // Loop mode specific validation
-    if (input.mode === 'loop') {
-        if (!/function\s+draw\s*\(\s*\)/.test(input.source)) {
-            throw new Error('[Code Mode Protocol Error] Loop mode requires a draw() function');
-        }
-        if (/noLoop\s*\(\s*\)/.test(input.source)) {
-            throw new Error('[Code Mode Protocol Error] noLoop() is forbidden in Loop mode');
-        }
-    }
-}
-/**
- * Create protocol metadata for the execution result
- */
-function createMetadata(input, vars) {
-    return {
-        ...PROTOCOL_IDENTITY,
-        seed: input.seed,
-        vars,
-        width: input.width,
-        height: input.height,
-        mode: input.mode,
-        ...(input.mode === 'loop' && input.totalFrames ? { totalFrames: input.totalFrames } : {}),
-    };
-}
-/**
- * Execute Code Mode in Static mode - delegates to static-engine.ts
- */
-async function executeStatic(input, vars) {
-    console.log('[CodeMode] Rendered via @nexart/codemode-sdk (Protocol v1.2.0)');
-    console.log('[CodeMode] Execution: Static mode — delegating to static-engine');
-    return new Promise((resolve, reject) => {
-        runStaticMode({
-            mode: 'static',
-            width: input.width,
-            height: input.height,
-        }, {
-            code: input.source,
-            seed: input.seed,
-            vars: vars,
-            onComplete: (result) => {
-                resolve({
-                    image: 'blob' in result ? result.blob : undefined,
-                    frames: 'imageData' in result ? [result.imageData] : undefined,
-                    metadata: createMetadata(input, vars),
-                });
-            },
-            onError: (error) => {
-                reject(error);
-            },
-        });
-    });
-}
-/**
- * Execute Code Mode in Loop mode - delegates to loop-engine.ts
- */
-async function executeLoop(input, vars) {
-    console.log('[CodeMode] Rendered via @nexart/codemode-sdk (Protocol v1.2.0)');
-    console.log(`[CodeMode] Execution: Loop mode — delegating to loop-engine (${input.totalFrames} frames)`);
-    const fps = DEFAULT_CONFIG.fps;
-    const duration = (input.totalFrames || 60) / fps;
-    return new Promise((resolve, reject) => {
-        runLoopMode({
-            mode: 'loop',
-            width: input.width,
-            height: input.height,
-            duration: duration,
-            fps: fps,
-        }, {
-            code: input.source,
-            seed: input.seed,
-            vars: vars,
-            onComplete: (result) => {
-                resolve({
-                    video: 'blob' in result && result.type === 'video' ? result.blob : undefined,
-                    metadata: createMetadata(input, vars),
-                });
-            },
-            onError: (error) => {
-                reject(error);
-            },
-        });
-    });
-}
-/**
- * executeCodeMode — Canonical Code Mode Execution Entry Point
- *
- * This is the ONLY official way to execute Code Mode.
- * All implementations MUST use this function.
- *
- * @param input - Execution parameters
- * @returns Promise<ExecuteCodeModeResult> - Execution result with protocol metadata
- *
- * @example
- * ```typescript
- * const result = await executeCodeMode({
- *   source: `function setup() { background(255); ellipse(width/2, height/2, 100); }`,
- *   width: 1950,
- *   height: 2400,
- *   seed: 12345,
- *   vars: [50, 75, 0, 0, 0, 0, 0, 0, 0, 0],
- *   mode: 'static'
- * });
- *
- * console.log(result.metadata.protocolVersion); // '1.2.0'
- * console.log(result.image); // PNG Blob
- * ```
- */
-export async function executeCodeMode(input) {
-    // Validate input
-    validateInput(input);
-    // Normalize VAR values
-    const vars = normalizeVars(input.vars);
-    // ╔═══════════════════════════════════════════════════════════════════════╗
-    // ║  BUILDER MANIFEST CONTEXT (v1.6.0)                                    ║
-    // ║                                                                       ║
-    // ║  Internal context for builder attribution.                            ║
-    // ║  This is NOT exposed to sketch code, NOT serialized, NOT logged.      ║
-    // ║  Does NOT affect execution behavior or determinism.                   ║
-    // ╚═══════════════════════════════════════════════════════════════════════╝
-    const _executionContext = {
-        builderManifest: getBuilderManifest(),
-    };
-    // Note: _executionContext is intentionally unused.
-    // It prepares the SDK for future attribution without activating anything.
-    void _executionContext;
-    // Log protocol execution
-    console.log('[CodeMode] ════════════════════════════════════════════════');
-    console.log('[CodeMode] Protocol v1.2.0 — Phase 3 — HARD Enforcement');
-    console.log(`[CodeMode] Mode: ${input.mode}`);
-    console.log(`[CodeMode] Seed: ${input.seed}`);
-    console.log(`[CodeMode] VAR: [${vars.join(', ')}]`);
-    console.log('[CodeMode] ════════════════════════════════════════════════');
-    // Execute based on mode
-    if (input.mode === 'static') {
-        return executeStatic(input, vars);
-    }
-    else {
-        return executeLoop(input, vars);
-    }
-}
-/**
- * Validate code without executing
- */
-export function validateCodeModeSource(source, mode) {
-    const errors = [];
-    // Same forbidden patterns as validateInput per CODE_MODE_PROTOCOL.md
-    const forbiddenPatterns = [
-        { pattern: /setTimeout\s*\(/, name: 'setTimeout' },
-        { pattern: /setInterval\s*\(/, name: 'setInterval' },
-        { pattern: /requestAnimationFrame\s*\(/, name: 'requestAnimationFrame' },
-        { pattern: /Date\.now\s*\(/, name: 'Date.now() — use time variable instead' },
-        { pattern: /new\s+Date\s*\(/, name: 'new Date() — use time variable instead' },
-        { pattern: /Math\.random\s*\(/, name: 'Math.random() — use random() instead (seeded)' },
-        { pattern: /fetch\s*\(/, name: 'fetch() — external IO forbidden' },
-        { pattern: /XMLHttpRequest/, name: 'XMLHttpRequest — external IO forbidden' },
-        { pattern: /createCanvas\s*\(/, name: 'createCanvas() — canvas is pre-initialized' },
-        { pattern: /document\./, name: 'DOM access — document.* forbidden' },
-        { pattern: /window\./, name: 'DOM access — window.* forbidden' },
-        { pattern: /\bimport\s+/, name: 'import — external imports forbidden' },
-        { pattern: /\brequire\s*\(/, name: 'require() — external imports forbidden' },
-    ];
-    for (const { pattern, name } of forbiddenPatterns) {
-        if (pattern.test(source)) {
-            errors.push(`Forbidden pattern: ${name}`);
-        }
-    }
-    if (mode === 'loop') {
-        if (!/function\s+draw\s*\(\s*\)/.test(source)) {
-            errors.push('Loop mode requires a draw() function');
-        }
-        if (/noLoop\s*\(\s*\)/.test(source)) {
-            errors.push('noLoop() is forbidden in Loop mode');
-        }
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-    };
-}