@nexart/codemode-sdk 1.6.0 → 1.8.0

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"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,55 +1,63 @@
 /**
- * NexArt Code Mode Runtime SDK
- * Version: 1.1.0 (Protocol v1.0.0)
+ * NexArt Code Mode Runtime SDK - App Integration Layer
  *
  * ╔══════════════════════════════════════════════════════════════════════════╗
- * ║  @nexart/codemode-sdk — Canonical Code Mode Authority                    ║
+ * ║  LOCAL SDK WRAPPER                                                       ║
  * ║                                                                          ║
- * ║  This SDK defines the official Code Mode execution surface.              ║
- * ║  All implementations (NexArt, ByX, external) MUST use this SDK.          ║
+ * ║  This file re-exports the core runtime from @nexart/codemode-sdk (npm)   ║
+ * ║  and adds app-specific integrations (SoundArt, Noise, etc.)              ║
  * ║                                                                          ║
- * ║  Protocol: nexart                                                        ║
- * ║  Engine: codemode                                                        ║
- * ║  SDK Version: 1.1.0                                                      ║
- * ║  Protocol Version: 1.0.0                                                 ║
- * ║  Phase: 1                                                                ║
- * ║  Enforcement: HARD                                                       ║
+ * ║  For core Code Mode: import from '@nexart/codemode-sdk'                  ║
+ * ║  For app integrations: import from 'sdk/codemode'                        ║
  * ╚══════════════════════════════════════════════════════════════════════════╝
- *
- * @example
- * ```typescript
- * import { executeCodeMode } from '@nexart/codemode-sdk';
- *
- * const result = await executeCodeMode({
- *   source: `function setup() { background(255); ellipse(width/2, height/2, 100); }`,
- *   width: 1950,
- *   height: 2400,
- *   seed: 12345,
- *   vars: [50, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- *   mode: 'static'
- * });
- *
- * console.log(result.metadata.protocolVersion); // '1.0.0'
- * ```
  */
 // ═══════════════════════════════════════════════════════════════════════════
-// CANONICAL EXECUTION ENTRY POINT
+// 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 { executeCodeMode, validateCodeModeSource } from './execute';
-export { PROTOCOL_IDENTITY } from './types';
+export { createP5Runtime, injectTimeVariables, injectProtocolVariables, createProtocolVAR } from './p5-runtime';
 // ═══════════════════════════════════════════════════════════════════════════
-// LEGACY ENGINE API (use executeCodeMode for new implementations)
+// LEGACY ENGINE API (kept for backwards compatibility)
 // ═══════════════════════════════════════════════════════════════════════════
 export { createEngine } from './engine';
-export { DEFAULT_CONFIG } from './types';
+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';
-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';
+// ═══════════════════════════════════════════════════════════════════════════
+// 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/runtime.d.ts

@@ -0,0 +1,52 @@
+/**
+ * NexArt Code Mode SDK - Agent-First Runtime Authority Layer
+ * Version: 1.8.0 (Protocol v1.2.0)
+ *
+ * ╔══════════════════════════════════════════════════════════════════════════╗
+ * ║  AGENT-FIRST RUNTIME — DETERMINISTIC EXECUTION AUTHORITY                 ║
+ * ║                                                                          ║
+ * ║  This module provides a high-level runtime API designed for AI agents    ║
+ * ║  (Replit, Lovable, Claude Code) to reliably execute deterministic code.  ║
+ * ║                                                                          ║
+ * ║  Key Features:                                                           ║
+ * ║  - Deterministic PRNG: runtime.random() (seeded Mulberry32)              ║
+ * ║  - Deterministic noise: runtime.noise(x, y?, z?) (seeded Perlin)         ║
+ * ║  - Strict mode: Throws on Math.random, Date.now, performance.now         ║
+ * ║  - Digest: Stable hash for verification and replay                       ║
+ * ║  - State snapshot: Canonical state for bundles                           ║
+ * ║                                                                          ║
+ * ║  BROWSER-SAFE: No Node.js dependencies. Works in Vite/Next/React.        ║
+ * ╚══════════════════════════════════════════════════════════════════════════╝
+ */
+export declare const RUNTIME_VERSION = "1.8.0";
+export interface RuntimeOptions {
+    seed: string | number;
+    vars?: number[];
+    strict?: boolean;
+    mode?: 'static' | 'loop';
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeState {
+    sdkVersion: string;
+    seed: number;
+    vars: number[];
+    mode: 'static' | 'loop';
+    metadata?: Record<string, unknown>;
+}
+export interface NexArtRuntime {
+    random(): number;
+    randomInt(min: number, max: number): number;
+    randomRange(min: number, max: number): number;
+    noise(x: number, y?: number, z?: number): number;
+    run<T>(fn: () => T): T;
+    digest(): string;
+    getState(): RuntimeState;
+    getSeed(): number;
+    readonly strict: boolean;
+}
+export declare function createRuntime(options: RuntimeOptions): NexArtRuntime;
+export declare const NexArtRuntime: {
+    create: typeof createRuntime;
+    VERSION: string;
+};
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,eAAO,MAAM,eAAe,UAAU,CAAC;AAEvC,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,IAAI,MAAM,CAAC;IACjB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5C,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9C,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACjD,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;IACvB,MAAM,IAAI,MAAM,CAAC;IACjB,QAAQ,IAAI,YAAY,CAAC;IACzB,OAAO,IAAI,MAAM,CAAC;IAClB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAqGD,wBAAgB,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,aAAa,CAuHpE;AAED,eAAO,MAAM,aAAa;;;CAGzB,CAAC"}

package/dist/runtime.js

@@ -0,0 +1,219 @@
+/**
+ * NexArt Code Mode SDK - Agent-First Runtime Authority Layer
+ * Version: 1.8.0 (Protocol v1.2.0)
+ *
+ * ╔══════════════════════════════════════════════════════════════════════════╗
+ * ║  AGENT-FIRST RUNTIME — DETERMINISTIC EXECUTION AUTHORITY                 ║
+ * ║                                                                          ║
+ * ║  This module provides a high-level runtime API designed for AI agents    ║
+ * ║  (Replit, Lovable, Claude Code) to reliably execute deterministic code.  ║
+ * ║                                                                          ║
+ * ║  Key Features:                                                           ║
+ * ║  - Deterministic PRNG: runtime.random() (seeded Mulberry32)              ║
+ * ║  - Deterministic noise: runtime.noise(x, y?, z?) (seeded Perlin)         ║
+ * ║  - Strict mode: Throws on Math.random, Date.now, performance.now         ║
+ * ║  - Digest: Stable hash for verification and replay                       ║
+ * ║  - State snapshot: Canonical state for bundles                           ║
+ * ║                                                                          ║
+ * ║  BROWSER-SAFE: No Node.js dependencies. Works in Vite/Next/React.        ║
+ * ╚══════════════════════════════════════════════════════════════════════════╝
+ */
+export const RUNTIME_VERSION = '1.8.0';
+function hashSeed(seed) {
+    if (typeof seed === 'number') {
+        return Math.floor(seed) >>> 0;
+    }
+    let hash = 0;
+    for (let i = 0; i < seed.length; i++) {
+        const char = seed.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash >>> 0;
+    }
+    return hash || 1;
+}
+function createSeededRNG(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a += 0x6D2B79F5;
+        let t = Math.imul(a ^ (a >>> 15), a | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+function createSeededNoise(seed) {
+    const permutation = [];
+    const rng = createSeededRNG(seed);
+    for (let i = 0; i < 256; i++) {
+        permutation[i] = i;
+    }
+    for (let i = 255; i > 0; i--) {
+        const j = Math.floor(rng() * (i + 1));
+        [permutation[i], permutation[j]] = [permutation[j], permutation[i]];
+    }
+    for (let i = 0; i < 256; i++) {
+        permutation[256 + i] = permutation[i];
+    }
+    const fade = (t) => t * t * t * (t * (t * 6 - 15) + 10);
+    const lerp = (a, b, t) => a + t * (b - a);
+    const grad = (hash, x, y, z) => {
+        const h = hash & 15;
+        const u = h < 8 ? x : y;
+        const v = h < 4 ? y : h === 12 || h === 14 ? x : z;
+        return ((h & 1) === 0 ? u : -u) + ((h & 2) === 0 ? v : -v);
+    };
+    return (x, y = 0, z = 0) => {
+        const X = Math.floor(x) & 255;
+        const Y = Math.floor(y) & 255;
+        const Z = Math.floor(z) & 255;
+        x -= Math.floor(x);
+        y -= Math.floor(y);
+        z -= Math.floor(z);
+        const u = fade(x);
+        const v = fade(y);
+        const w = fade(z);
+        const A = permutation[X] + Y;
+        const AA = permutation[A] + Z;
+        const AB = permutation[A + 1] + Z;
+        const B = permutation[X + 1] + Y;
+        const BA = permutation[B] + Z;
+        const BB = permutation[B + 1] + Z;
+        return (lerp(lerp(lerp(grad(permutation[AA], x, y, z), grad(permutation[BA], x - 1, y, z), u), lerp(grad(permutation[AB], x, y - 1, z), grad(permutation[BB], x - 1, y - 1, z), u), v), lerp(lerp(grad(permutation[AA + 1], x, y, z - 1), grad(permutation[BA + 1], x - 1, y, z - 1), u), lerp(grad(permutation[AB + 1], x, y - 1, z - 1), grad(permutation[BB + 1], x - 1, y - 1, z - 1), u), v), w) + 1) / 2;
+    };
+}
+function stableStringify(obj) {
+    if (obj === null)
+        return 'null';
+    if (obj === undefined)
+        return 'undefined';
+    if (typeof obj !== 'object')
+        return JSON.stringify(obj);
+    if (Array.isArray(obj)) {
+        return '[' + obj.map(stableStringify).join(',') + ']';
+    }
+    const keys = Object.keys(obj).sort();
+    const pairs = keys.map(k => `${JSON.stringify(k)}:${stableStringify(obj[k])}`);
+    return '{' + pairs.join(',') + '}';
+}
+function fnv1aHash(str) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    const h1 = (hash >>> 0).toString(16).padStart(8, '0');
+    let hash2 = 0x811c9dc5;
+    for (let i = str.length - 1; i >= 0; i--) {
+        hash2 ^= str.charCodeAt(i);
+        hash2 = Math.imul(hash2, 0x01000193);
+    }
+    const h2 = (hash2 >>> 0).toString(16).padStart(8, '0');
+    return h1 + h2;
+}
+export function createRuntime(options) {
+    const numericSeed = hashSeed(options.seed);
+    const vars = options.vars ?? [];
+    const mode = options.mode ?? 'static';
+    const strict = options.strict ?? false;
+    const metadata = options.metadata;
+    if (vars.length > 10) {
+        throw new Error(`[NexArt Runtime] vars array must have 0-10 elements, got ${vars.length}`);
+    }
+    for (let i = 0; i < vars.length; i++) {
+        if (typeof vars[i] !== 'number' || !Number.isFinite(vars[i])) {
+            throw new Error(`[NexArt Runtime] vars[${i}] must be a finite number`);
+        }
+        if (vars[i] < 0 || vars[i] > 100) {
+            throw new Error(`[NexArt Runtime] vars[${i}] must be in range 0-100, got ${vars[i]}`);
+        }
+    }
+    const paddedVars = [...vars];
+    while (paddedVars.length < 10) {
+        paddedVars.push(0);
+    }
+    const rng = createSeededRNG(numericSeed);
+    const noiseFunc = createSeededNoise(numericSeed);
+    const state = {
+        sdkVersion: RUNTIME_VERSION,
+        seed: numericSeed,
+        vars: paddedVars,
+        mode,
+        ...(metadata !== undefined && { metadata }),
+    };
+    function random() {
+        return rng();
+    }
+    function randomInt(min, max) {
+        const range = max - min + 1;
+        return Math.floor(rng() * range) + min;
+    }
+    function randomRange(min, max) {
+        return rng() * (max - min) + min;
+    }
+    function noise(x, y, z) {
+        return noiseFunc(x, y ?? 0, z ?? 0);
+    }
+    function run(fn) {
+        if (!strict) {
+            return fn();
+        }
+        const originalMathRandom = Math.random;
+        const originalDateNow = Date.now;
+        const hasPerformance = typeof performance !== 'undefined' && performance !== null;
+        const originalPerformanceNow = hasPerformance ? performance.now : undefined;
+        const throwMathRandom = () => {
+            throw new Error('NEXART_STRICT: Non-deterministic API used: Math.random. Use runtime.random() instead.');
+        };
+        const throwDateNow = () => {
+            throw new Error('NEXART_STRICT: Non-deterministic API used: Date.now. Pass time as an input or use deterministic counters.');
+        };
+        const throwPerformanceNow = () => {
+            throw new Error('NEXART_STRICT: Non-deterministic API used: performance.now.');
+        };
+        try {
+            Math.random = throwMathRandom;
+            Date.now = throwDateNow;
+            if (hasPerformance && originalPerformanceNow) {
+                performance.now = throwPerformanceNow;
+            }
+            return fn();
+        }
+        finally {
+            Math.random = originalMathRandom;
+            Date.now = originalDateNow;
+            if (hasPerformance && originalPerformanceNow) {
+                performance.now = originalPerformanceNow;
+            }
+        }
+    }
+    function digest() {
+        const input = stableStringify({
+            sdkVersion: RUNTIME_VERSION,
+            seed: numericSeed,
+            vars: paddedVars,
+            mode,
+            ...(metadata !== undefined && { metadata }),
+        });
+        return fnv1aHash(input);
+    }
+    function getState() {
+        return { ...state, vars: [...state.vars] };
+    }
+    function getSeed() {
+        return numericSeed;
+    }
+    return Object.freeze({
+        random,
+        randomInt,
+        randomRange,
+        noise,
+        run,
+        digest,
+        getState,
+        getSeed,
+        strict,
+    });
+}
+export const NexArtRuntime = {
+    create: createRuntime,
+    VERSION: RUNTIME_VERSION,
+};

package/dist/sdk/codemode/builder-manifest.d.ts

@@ -0,0 +1,79 @@
+/**
+ * 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.             ║
+ * ╚══════════════════════════════════════════════════════════════════════════╝
+ */
+import type { NexArtBuilderManifest } from './types';
+/**
+ * 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 declare function registerBuilderManifest(manifest?: NexArtBuilderManifest): void;
+/**
+ * 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 declare function getBuilderManifest(): NexArtBuilderManifest | null;
+/**
+ * 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 declare function clearBuilderManifest(): void;
+//# sourceMappingURL=builder-manifest.d.ts.map

package/dist/sdk/codemode/builder-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder-manifest.d.ts","sourceRoot":"","sources":["../../../builder-manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAKrD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,CAAC,EAAE,qBAAqB,GAAG,IAAI,CAiB9E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,IAAI,qBAAqB,GAAG,IAAI,CAEjE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C"}

package/dist/sdk/codemode/builder-manifest.js

@@ -0,0 +1,97 @@
+/**
+ * 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/sdk/codemode/core-index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @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.1.1";
+export declare const SDK_NAME = "@nexart/codemode-sdk";
+//# sourceMappingURL=core-index.d.ts.map

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

@@ -0,0 +1 @@
+{"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/sdk/codemode/core-index.js

@@ -0,0 +1,26 @@
+/**
+ * @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.1.1';
+export const SDK_NAME = '@nexart/codemode-sdk';

package/dist/sdk/codemode/engine.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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/sdk/codemode/engine.d.ts.map

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