@nexart/codemode-sdk 1.1.1 → 1.5.0

package/dist/p5-runtime.js

@@ -2,7 +2,7 @@
  * NexArt Code Mode Runtime SDK - p5-like Runtime
  *
  * ╔══════════════════════════════════════════════════════════════════════════╗
- * ║  CODE MODE PROTOCOL v1.0.0 (Phase 1) — LOCKED                            ║
+ * ║  CODE MODE PROTOCOL v1.2.0 (Phase 3) — STABLE                             ║
  * ║                                                                          ║
  * ║  Status: HARD PROTOCOL ENFORCEMENT                                       ║
  * ║  This is the stable, canonical execution surface.                        ║
@@ -32,8 +32,8 @@
  * This constant defines the locked protocol version.
  * Changes to the execution surface require a version bump.
  */
-export const CODE_MODE_PROTOCOL_VERSION = '1.0.0';
-export const CODE_MODE_PROTOCOL_PHASE = 1;
+export const CODE_MODE_PROTOCOL_VERSION = '1.2.0';
+export const CODE_MODE_PROTOCOL_PHASE = 3;
 export const CODE_MODE_ENFORCEMENT = 'HARD';
 /**
  * Create a seeded random number generator (Mulberry32)
@@ -100,6 +100,15 @@ export function createP5Runtime(canvas, width, height, config) {
     let currentStrokeWeight = 1;
     let colorModeSettings = { mode: 'RGB', maxR: 255, maxG: 255, maxB: 255, maxA: 255 };
     let shapeStarted = false;
+    let shapeVertices = [];
+    // Pixel array for pixel manipulation
+    let pixelData = null;
+    let imageDataObj = null;
+    // Text state
+    let currentTextSize = 12;
+    let currentTextFont = 'sans-serif';
+    let currentTextAlignH = 'left';
+    let currentTextAlignV = 'alphabetic';
     // Seeded random state
     let randomSeedValue = config?.seed ?? Math.floor(Math.random() * 2147483647);
     let rng = createSeededRNG(randomSeedValue);
@@ -248,6 +257,7 @@ export function createP5Runtime(canvas, width, height, config) {
         // Constants
         PI: Math.PI,
         TWO_PI: Math.PI * 2,
+        TAU: Math.PI * 2,
         HALF_PI: Math.PI / 2,
         QUARTER_PI: Math.PI / 4,
         // Shape mode constants
@@ -256,11 +266,25 @@ export function createP5Runtime(canvas, width, height, config) {
         CORNERS: 'corners',
         RADIUS: 'radius',
         ROUND: 'round',
-        SQUARE: 'square',
-        PROJECT: 'project',
+        SQUARE: 'butt',
+        PROJECT: 'square',
         MITER: 'miter',
         BEVEL: 'bevel',
         CLOSE: 'close',
+        PIE: 'pie',
+        CHORD: 'chord',
+        OPEN: 'open',
+        // Blend mode constants (v1.1)
+        NORMAL: 'source-over',
+        ADD: 'lighter',
+        MULTIPLY: 'multiply',
+        SCREEN: 'screen',
+        // Text alignment constants
+        LEFT: 'left',
+        RIGHT: 'right',
+        TOP: 'top',
+        BOTTOM: 'bottom',
+        BASELINE: 'alphabetic',
         // Canvas operations
         background: (...args) => {
             ctx.save();
@@ -271,6 +295,23 @@ export function createP5Runtime(canvas, width, height, config) {
         clear: () => {
             ctx.clearRect(0, 0, width, height);
         },
+        blendMode: (mode) => {
+            const modeMap = {
+                'source-over': 'source-over',
+                'NORMAL': 'source-over',
+                'lighter': 'lighter',
+                'ADD': 'lighter',
+                'multiply': 'multiply',
+                'MULTIPLY': 'multiply',
+                'screen': 'screen',
+                'SCREEN': 'screen',
+            };
+            const compositeOp = modeMap[mode];
+            if (!compositeOp) {
+                throw new Error(`[Code Mode Protocol Error] Unsupported blend mode: ${mode}. Supported: NORMAL, ADD, MULTIPLY, SCREEN`);
+            }
+            ctx.globalCompositeOperation = compositeOp;
+        },
         // Color functions
         fill: (...args) => {
             fillEnabled = true;
@@ -292,6 +333,29 @@ export function createP5Runtime(canvas, width, height, config) {
             currentStrokeWeight = weight;
             ctx.lineWidth = weight;
         },
+        strokeCap: (cap) => {
+            const capMap = {
+                'round': 'round',
+                'ROUND': 'round',
+                'square': 'butt',
+                'SQUARE': 'butt',
+                'project': 'square',
+                'PROJECT': 'square',
+                'butt': 'butt',
+            };
+            ctx.lineCap = capMap[cap] || 'round';
+        },
+        strokeJoin: (join) => {
+            const joinMap = {
+                'miter': 'miter',
+                'MITER': 'miter',
+                'bevel': 'bevel',
+                'BEVEL': 'bevel',
+                'round': 'round',
+                'ROUND': 'round',
+            };
+            ctx.lineJoin = joinMap[join] || 'miter';
+        },
         colorMode: (mode, max1, max2, max3, maxA) => {
             colorModeSettings = {
                 mode: mode.toUpperCase(),
@@ -451,21 +515,144 @@ export function createP5Runtime(canvas, width, height, config) {
             if (strokeEnabled)
                 ctx.stroke();
         },
+        // Bezier and curve functions
+        bezier: (x1, y1, cx1, cy1, cx2, cy2, x2, y2) => {
+            ctx.beginPath();
+            ctx.moveTo(x1, y1);
+            ctx.bezierCurveTo(cx1, cy1, cx2, cy2, x2, y2);
+            if (strokeEnabled)
+                ctx.stroke();
+        },
+        curve: (x1, y1, x2, y2, x3, y3, x4, y4) => {
+            // Catmull-Rom spline conversion to cubic bezier
+            // The curve is drawn from (x2,y2) to (x3,y3) using (x1,y1) and (x4,y4) as control points
+            const tension = 1 / 6;
+            const cp1x = x2 + (x3 - x1) * tension;
+            const cp1y = y2 + (y3 - y1) * tension;
+            const cp2x = x3 - (x4 - x2) * tension;
+            const cp2y = y3 - (y4 - y2) * tension;
+            ctx.beginPath();
+            ctx.moveTo(x2, y2);
+            ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x3, y3);
+            if (strokeEnabled)
+                ctx.stroke();
+        },
+        // Shape helpers (v1.1)
+        polygon: (cx, cy, radius, sides, rotation = 0) => {
+            ctx.beginPath();
+            for (let i = 0; i < sides; i++) {
+                const angle = rotation + (i / sides) * Math.PI * 2 - Math.PI / 2;
+                const x = cx + Math.cos(angle) * radius;
+                const y = cy + Math.sin(angle) * radius;
+                if (i === 0) {
+                    ctx.moveTo(x, y);
+                }
+                else {
+                    ctx.lineTo(x, y);
+                }
+            }
+            ctx.closePath();
+            if (fillEnabled)
+                ctx.fill();
+            if (strokeEnabled)
+                ctx.stroke();
+        },
+        star: (cx, cy, innerRadius, outerRadius, points, rotation = 0) => {
+            ctx.beginPath();
+            const totalPoints = points * 2;
+            for (let i = 0; i < totalPoints; i++) {
+                const angle = rotation + (i / totalPoints) * Math.PI * 2 - Math.PI / 2;
+                const radius = i % 2 === 0 ? outerRadius : innerRadius;
+                const x = cx + Math.cos(angle) * radius;
+                const y = cy + Math.sin(angle) * radius;
+                if (i === 0) {
+                    ctx.moveTo(x, y);
+                }
+                else {
+                    ctx.lineTo(x, y);
+                }
+            }
+            ctx.closePath();
+            if (fillEnabled)
+                ctx.fill();
+            if (strokeEnabled)
+                ctx.stroke();
+        },
         // Vertex-based shapes
         beginShape: () => {
-            ctx.beginPath();
+            shapeVertices = [];
             shapeStarted = false;
         },
         vertex: (x, y) => {
-            if (!shapeStarted) {
-                ctx.moveTo(x, y);
-                shapeStarted = true;
-            }
-            else {
-                ctx.lineTo(x, y);
-            }
+            shapeVertices.push({ x, y, type: 'vertex' });
+        },
+        curveVertex: (x, y) => {
+            shapeVertices.push({ x, y, type: 'curve' });
+        },
+        bezierVertex: (cx1, cy1, cx2, cy2, x, y) => {
+            shapeVertices.push({ x, y, type: 'bezier', cx1, cy1, cx2, cy2 });
         },
         endShape: (mode) => {
+            if (shapeVertices.length === 0)
+                return;
+            ctx.beginPath();
+            // Process vertices in sequence, handling mixed types correctly
+            let started = false;
+            let curveBuffer = [];
+            const tension = 1 / 6;
+            const flushCurveBuffer = () => {
+                if (curveBuffer.length >= 4) {
+                    // Draw Catmull-Rom spline from buffered curve vertices
+                    // First and last points are control points only
+                    if (!started) {
+                        ctx.moveTo(curveBuffer[1].x, curveBuffer[1].y);
+                        started = true;
+                    }
+                    else {
+                        ctx.lineTo(curveBuffer[1].x, curveBuffer[1].y);
+                    }
+                    for (let i = 1; i < curveBuffer.length - 2; i++) {
+                        const p0 = curveBuffer[i - 1];
+                        const p1 = curveBuffer[i];
+                        const p2 = curveBuffer[i + 1];
+                        const p3 = curveBuffer[i + 2];
+                        const cp1x = p1.x + (p2.x - p0.x) * tension;
+                        const cp1y = p1.y + (p2.y - p0.y) * tension;
+                        const cp2x = p2.x - (p3.x - p1.x) * tension;
+                        const cp2y = p2.y - (p3.y - p1.y) * tension;
+                        ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, p2.x, p2.y);
+                    }
+                }
+                curveBuffer = [];
+            };
+            for (let i = 0; i < shapeVertices.length; i++) {
+                const v = shapeVertices[i];
+                if (v.type === 'curve') {
+                    curveBuffer.push({ x: v.x, y: v.y });
+                }
+                else {
+                    // Flush any pending curve vertices before processing non-curve vertex
+                    if (curveBuffer.length > 0) {
+                        flushCurveBuffer();
+                    }
+                    if (v.type === 'vertex') {
+                        if (!started) {
+                            ctx.moveTo(v.x, v.y);
+                            started = true;
+                        }
+                        else {
+                            ctx.lineTo(v.x, v.y);
+                        }
+                    }
+                    else if (v.type === 'bezier' && started) {
+                        ctx.bezierCurveTo(v.cx1, v.cy1, v.cx2, v.cy2, v.x, v.y);
+                    }
+                }
+            }
+            // Flush any remaining curve vertices at the end
+            if (curveBuffer.length > 0) {
+                flushCurveBuffer();
+            }
             if (mode === 'close' || mode === 'CLOSE') {
                 ctx.closePath();
             }
@@ -473,6 +660,7 @@ export function createP5Runtime(canvas, width, height, config) {
                 ctx.fill();
             if (strokeEnabled)
                 ctx.stroke();
+            shapeVertices = [];
             shapeStarted = false;
         },
         // Transform functions
@@ -497,6 +685,12 @@ export function createP5Runtime(canvas, width, height, config) {
         resetMatrix: () => {
             ctx.setTransform(1, 0, 0, 1, 0, 0);
         },
+        shearX: (angle) => {
+            ctx.transform(1, 0, Math.tan(angle), 1, 0, 0);
+        },
+        shearY: (angle) => {
+            ctx.transform(1, Math.tan(angle), 0, 1, 0, 0);
+        },
         // Math functions - SEEDED for determinism
         random: (min, max) => {
             // Support random() with arrays
@@ -544,6 +738,47 @@ export function createP5Runtime(canvas, width, height, config) {
                 noiseFalloff = Math.max(0, Math.min(1, falloff));
             }
         },
+        // Noise extensions (v1.1) - use seeded noise internally
+        fbm: (x, y, octaves = 4, falloff = 0.5) => {
+            let total = 0;
+            let frequency = 1;
+            let amplitude = 1;
+            let maxValue = 0;
+            for (let i = 0; i < octaves; i++) {
+                total += noiseFunc(x * frequency, y * frequency) * amplitude;
+                maxValue += amplitude;
+                amplitude *= falloff;
+                frequency *= 2;
+            }
+            return total / maxValue;
+        },
+        ridgedNoise: (x, y) => {
+            // Ridged noise: absolute value creates ridge-like patterns
+            let total = 0;
+            let frequency = 1;
+            let amplitude = 1;
+            let maxValue = 0;
+            for (let i = 0; i < 4; i++) {
+                const n = noiseFunc(x * frequency, y * frequency);
+                total += (1 - Math.abs(n * 2 - 1)) * amplitude;
+                maxValue += amplitude;
+                amplitude *= 0.5;
+                frequency *= 2;
+            }
+            return total / maxValue;
+        },
+        curlNoise: (x, y) => {
+            // Curl noise: compute gradient and rotate 90 degrees
+            const eps = 0.0001;
+            const n1 = noiseFunc(x + eps, y);
+            const n2 = noiseFunc(x - eps, y);
+            const n3 = noiseFunc(x, y + eps);
+            const n4 = noiseFunc(x, y - eps);
+            const dx = (n1 - n2) / (2 * eps);
+            const dy = (n3 - n4) / (2 * eps);
+            // Rotate 90 degrees: (dx, dy) -> (-dy, dx)
+            return { x: -dy, y: dx };
+        },
         map: (value, start1, stop1, start2, stop2) => {
             return start2 + (stop2 - start2) * ((value - start1) / (stop1 - start1));
         },
@@ -583,16 +818,166 @@ export function createP5Runtime(canvas, width, height, config) {
         log: Math.log,
         min: Math.min,
         max: Math.max,
+        int: (n) => Math.floor(n),
+        sq: (n) => n * n,
+        fract: (n) => n - Math.floor(n),
+        sign: (n) => n > 0 ? 1 : n < 0 ? -1 : 0,
+        // Vector helpers (v1.1) - plain objects, no mutation
+        vec: (x, y) => ({ x, y }),
+        vecAdd: (a, b) => ({
+            x: a.x + b.x,
+            y: a.y + b.y
+        }),
+        vecSub: (a, b) => ({
+            x: a.x - b.x,
+            y: a.y - b.y
+        }),
+        vecMult: (v, s) => ({
+            x: v.x * s,
+            y: v.y * s
+        }),
+        vecMag: (v) => Math.sqrt(v.x * v.x + v.y * v.y),
+        vecNorm: (v) => {
+            const m = Math.sqrt(v.x * v.x + v.y * v.y);
+            return m === 0 ? { x: 0, y: 0 } : { x: v.x / m, y: v.y / m };
+        },
+        vecDist: (a, b) => {
+            const dx = b.x - a.x;
+            const dy = b.y - a.y;
+            return Math.sqrt(dx * dx + dy * dy);
+        },
+        // Easing functions (v1.1) - pure functions, t ∈ [0,1] → [0,1]
+        easeIn: (t) => t * t,
+        easeOut: (t) => t * (2 - t),
+        easeInOut: (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t,
+        easeCubic: (t) => t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2,
+        easeExpo: (t) => {
+            if (t === 0)
+                return 0;
+            if (t === 1)
+                return 1;
+            if (t < 0.5) {
+                return Math.pow(2, 20 * t - 10) / 2;
+            }
+            return (2 - Math.pow(2, -20 * t + 10)) / 2;
+        },
+        // Text functions
+        text: (str, x, y) => {
+            ctx.font = `${currentTextSize}px ${currentTextFont}`;
+            ctx.textAlign = currentTextAlignH;
+            ctx.textBaseline = currentTextAlignV;
+            if (fillEnabled) {
+                ctx.fillStyle = currentFill;
+                ctx.fillText(String(str), x, y);
+            }
+            if (strokeEnabled) {
+                ctx.strokeStyle = currentStroke;
+                ctx.strokeText(String(str), x, y);
+            }
+        },
+        textSize: (size) => {
+            currentTextSize = size;
+            ctx.font = `${currentTextSize}px ${currentTextFont}`;
+        },
+        textFont: (font) => {
+            currentTextFont = font;
+            ctx.font = `${currentTextSize}px ${currentTextFont}`;
+        },
+        textAlign: (horizAlign, vertAlign) => {
+            const hMap = {
+                'left': 'left', 'LEFT': 'left',
+                'center': 'center', 'CENTER': 'center',
+                'right': 'right', 'RIGHT': 'right',
+            };
+            const vMap = {
+                'top': 'top', 'TOP': 'top',
+                'bottom': 'bottom', 'BOTTOM': 'bottom',
+                'center': 'middle', 'CENTER': 'middle',
+                'baseline': 'alphabetic', 'BASELINE': 'alphabetic',
+            };
+            currentTextAlignH = hMap[horizAlign] || 'left';
+            if (vertAlign) {
+                currentTextAlignV = vMap[vertAlign] || 'alphabetic';
+            }
+        },
+        textWidth: (str) => {
+            ctx.font = `${currentTextSize}px ${currentTextFont}`;
+            return ctx.measureText(String(str)).width;
+        },
+        // Pixel manipulation (v1.2)
+        loadPixels: () => {
+            imageDataObj = ctx.getImageData(0, 0, width, height);
+            pixelData = imageDataObj.data;
+            p.pixels = pixelData;
+        },
+        updatePixels: () => {
+            if (imageDataObj && pixelData) {
+                ctx.putImageData(imageDataObj, 0, 0);
+            }
+        },
+        pixels: null,
+        get: (x, y) => {
+            const imgData = ctx.getImageData(Math.floor(x), Math.floor(y), 1, 1);
+            return [imgData.data[0], imgData.data[1], imgData.data[2], imgData.data[3]];
+        },
+        set: (x, y, c) => {
+            const fx = Math.floor(x);
+            const fy = Math.floor(y);
+            if (Array.isArray(c)) {
+                const imgData = ctx.createImageData(1, 1);
+                imgData.data[0] = c[0];
+                imgData.data[1] = c[1];
+                imgData.data[2] = c[2];
+                imgData.data[3] = c[3] ?? 255;
+                ctx.putImageData(imgData, fx, fy);
+            }
+            else {
+                const parsed = parseCssColor(c);
+                if (parsed) {
+                    const imgData = ctx.createImageData(1, 1);
+                    imgData.data[0] = parsed.r;
+                    imgData.data[1] = parsed.g;
+                    imgData.data[2] = parsed.b;
+                    imgData.data[3] = Math.round(parsed.a * 255);
+                    ctx.putImageData(imgData, fx, fy);
+                }
+            }
+        },
+        // Offscreen graphics (v1.2)
+        createGraphics: (w, h) => {
+            const offscreenCanvas = document.createElement('canvas');
+            offscreenCanvas.width = w;
+            offscreenCanvas.height = h;
+            const pg = createP5Runtime(offscreenCanvas, w, h, config);
+            // Add reference to canvas for image() drawing
+            pg._canvas = offscreenCanvas;
+            return pg;
+        },
+        // Draw image or graphics object to canvas
+        image: (src, x, y, w, h) => {
+            const srcCanvas = src._canvas || src;
+            if (srcCanvas instanceof HTMLCanvasElement) {
+                const dw = w ?? srcCanvas.width;
+                const dh = h ?? srcCanvas.height;
+                ctx.drawImage(srcCanvas, x, y, dw, dh);
+            }
+        },
         // Loop control (no-ops for SDK)
         noLoop: () => { },
         loop: () => { },
         redraw: () => { },
         frameRate: (fps) => { },
+        // totalFrames placeholder (injected by engine)
+        totalFrames: 0,
     };
     return p;
 }
 export function injectTimeVariables(p, time) {
     p.frameCount = time.frameCount;
+    p.t = time.t;
+    p.time = time.time;
+    p.tGlobal = time.tGlobal;
+    p.totalFrames = time.totalFrames;
 }
 /**
  * VAR Protocol Constants (Phase 1 — Protocol v1.0.0)

package/dist/static-engine.d.ts

@@ -1,6 +1,6 @@
 /**
  * NexArt Code Mode Runtime SDK - Static Engine
- * Protocol: v1.0.0 (Phase 1) — HARD ENFORCEMENT
+ * Protocol: v1.2.0 (Phase 3) — HARD ENFORCEMENT
  *
  * Static mode renderer: executes setup() only, captures single PNG.
  * Does NOT execute draw() - per NexArt Execution Specification v1.

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

@@ -1 +1 @@
-{"version":3,"file":"static-engine.d.ts","sourceRoot":"","sources":["../static-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAgB,MAAM,SAAS,CAAC;AAItE,wBAAsB,aAAa,CACjC,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,IAAI,CAAC,CAkGf"}
+{"version":3,"file":"static-engine.d.ts","sourceRoot":"","sources":["../static-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAgB,MAAM,SAAS,CAAC;AAItE,wBAAsB,aAAa,CACjC,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,IAAI,CAAC,CAmGf"}

package/dist/static-engine.js

@@ -1,6 +1,6 @@
 /**
  * NexArt Code Mode Runtime SDK - Static Engine
- * Protocol: v1.0.0 (Phase 1) — HARD ENFORCEMENT
+ * Protocol: v1.2.0 (Phase 3) — HARD ENFORCEMENT
  *
  * Static mode renderer: executes setup() only, captures single PNG.
  * Does NOT execute draw() - per NexArt Execution Specification v1.
@@ -26,12 +26,13 @@ export async function runStaticMode(config, options) {
         canvas.height = height;
         // Create p5 runtime with optional seed for determinism
         const p = createP5Runtime(canvas, width, height, { seed });
-        // Inject time variables (static = frame 0, t = 0)
+        // Inject time variables (static = frame 0, t = 0, totalFrames = 1)
         injectTimeVariables(p, {
             frameCount: 0,
             t: 0,
             time: 0,
             tGlobal: 0,
+            totalFrames: 1, // Static mode has 1 frame
         });
         // Inject protocol variables (VAR[0..9])
         injectProtocolVariables(p, vars);

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 /**
  * NexArt Code Mode Runtime SDK - Types
- * Version: 1.0.2 (Protocol v1.0.0)
+ * Version: 1.5.0 (Protocol v1.2.0)
  *
  * Type definitions for the Code Mode runtime engine.
  * This is the canonical type surface for @nexart/codemode-sdk.
@@ -12,8 +12,8 @@
 export declare const PROTOCOL_IDENTITY: {
     readonly protocol: "nexart";
     readonly engine: "codemode";
-    readonly protocolVersion: "1.0.0";
-    readonly phase: 1;
+    readonly protocolVersion: "1.2.0";
+    readonly phase: 3;
     readonly deterministic: true;
 };
 export type RenderMode = 'static' | 'loop';
@@ -56,6 +56,7 @@ export interface TimeVariables {
     t: number;
     time: number;
     tGlobal: number;
+    totalFrames: number;
 }
 /**
  * Protocol Variables (VAR[0..9])
@@ -92,8 +93,8 @@ export declare const DEFAULT_CONFIG: {
 export interface ProtocolMetadata {
     protocol: 'nexart';
     engine: 'codemode';
-    protocolVersion: '1.0.0';
-    phase: 1;
+    protocolVersion: '1.2.0';
+    phase: 3;
     deterministic: true;
     seed: number;
     vars: number[];

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -1,6 +1,6 @@
 /**
  * NexArt Code Mode Runtime SDK - Types
- * Version: 1.0.2 (Protocol v1.0.0)
+ * Version: 1.5.0 (Protocol v1.2.0)
  *
  * Type definitions for the Code Mode runtime engine.
  * This is the canonical type surface for @nexart/codemode-sdk.
@@ -12,8 +12,8 @@
 export const PROTOCOL_IDENTITY = {
     protocol: 'nexart',
     engine: 'codemode',
-    protocolVersion: '1.0.0',
-    phase: 1,
+    protocolVersion: '1.2.0',
+    phase: 3,
     deterministic: true,
 };
 /**

package/package.json

@@ -1,42 +1,36 @@
 {
   "name": "@nexart/codemode-sdk",
-  "version": "1.1.1",
-  "description": "NexArt Code Mode SDK - Canonical execution engine for deterministic generative art",
+  "version": "1.5.0",
+  "description": "NexArt Code Mode Runtime SDK - Deterministic generative art rendering engine (Protocol v1.2.0)",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "type": "module",
-  "main": "./dist/core-index.js",
-  "types": "./dist/core-index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/core-index.d.ts",
-      "import": "./dist/core-index.js"
-    }
-  },
   "files": [
-    "dist",
-    "README.md",
-    "CHANGELOG.md",
-    "CODE_MODE_PROTOCOL.md"
+    "dist"
   ],
   "scripts": {
     "build": "tsc",
-    "test": "npx tsx smoke-test.ts",
-    "prepublishOnly": "npm run build && npm run test"
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
   },
   "keywords": [
-    "nexart",
     "generative-art",
-    "nft",
     "p5js",
+    "canvas",
+    "rendering",
     "deterministic",
-    "codemode"
+    "nft",
+    "creative-coding"
   ],
-  "author": "NexArt",
-  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/artnames/nexart-codemode-sdk.git"
   },
-  "devDependencies": {
-    "typescript": "^5.0.0"
+  "author": "NexArt",
+  "publishConfig": {
+    "access": "public"
   }
 }