@nexart/codemode-sdk 1.6.0 → 1.7.0

package/CHANGELOG.md

@@ -4,6 +4,47 @@ All notable changes to @nexart/codemode-sdk will be documented in this file.
 
 ---
 
+## [1.7.0] — 2026-01-21
+
+### Added — Browser-Safe Entrypoint + Conditional Exports
+
+**Packaging/Exports Update — No Breaking Changes**
+
+This release makes the SDK reliably usable in browser environments (Vite/React) without any Node.js dependency leakage.
+
+#### New Entry Points
+- **`@nexart/codemode-sdk/browser`** — Browser-safe modules only
+  - All types, P5 runtime, loop engine, execution sandbox, validation, builder manifest
+  - Does NOT include static-engine or executeCodeMode (which require Node.js canvas)
+- **`@nexart/codemode-sdk/node`** — Full SDK for Node.js
+  - Everything from browser entry plus static-engine and executeCodeMode
+  - Requires `canvas` package for static rendering
+
+#### Package.json Conditional Exports
+- Default import (`.`) uses conditional exports:
+  - Browser bundlers (Vite, webpack) → browser entry
+  - Node.js → node entry
+- Explicit subpaths for direct control: `./browser` and `./node`
+
+#### Why This Matters
+- AI agents and bundlers will no longer accidentally import Node.js modules
+- Vite/React apps can safely import without "createRequire is not defined" errors
+- Server-side code gets full functionality including static image rendering
+
+#### Files Added
+- `entry/browser.ts` — Browser-safe entry point
+- `entry/node.ts` — Node.js entry point (re-exports browser + adds static-engine)
+
+### Unchanged
+
+- No changes to protocol behavior or determinism
+- No changes to protocol version (remains v1.2.0)
+- No changes to API surface (all functions work the same)
+- Full backward compatibility with v1.6.x
+- Existing sketches run unchanged
+
+---
+
 ## [1.6.0] — 2026-01-12
 
 ### Added — Licensing & Builder Identity Scaffolding

package/README.md

@@ -1,6 +1,6 @@
 # NexArt Code Mode Runtime SDK
 
-**Version: 1.6.0 (Protocol v1.2.0)**
+**Version: 1.7.0 (Protocol v1.2.0)**
 
 ╔══════════════════════════════════════════════════════════════════════════════╗
 ║  @nexart/codemode-sdk — Canonical Execution Surface                          ║
@@ -9,7 +9,7 @@
 ║                                                                              ║
 ║  Protocol: nexart                                                            ║
 ║  Engine: codemode                                                            ║
-║  SDK Version: 1.6.0                                                          ║
+║  SDK Version: 1.7.0                                                          ║
 ║  Protocol Version: 1.2.0                                                     ║
 ║  Phase: 3                                                                    ║
 ║  Enforcement: HARD                                                           ║
@@ -62,6 +62,32 @@ The answer is: "Whatever @nexart/codemode-sdk does — that is the protocol."
 
 ---
 
+## What's New in v1.7.0
+
+**Browser-Safe Entrypoint + Conditional Exports**
+
+This release makes the SDK reliably usable in browser environments (Vite/React) without any Node.js dependency leakage.
+
+### New Entry Points
+- `@nexart/codemode-sdk/browser` — Browser-safe modules only (no Node.js dependencies)
+- `@nexart/codemode-sdk/node` — Full SDK including static-engine (requires `canvas` package)
+
+### Package.json Conditional Exports
+- Default import (`.`) now uses conditional exports: browser gets browser entry, Node gets Node entry
+- Explicit subpaths: `./browser` and `./node` for direct control
+
+### Why This Matters
+- AI agents and bundlers will no longer accidentally import Node.js modules in browser builds
+- Vite/React apps can safely import the SDK without "createRequire is not defined" errors
+- Server-side code gets full functionality including static image rendering
+
+### No Breaking Changes
+- Protocol behavior and determinism unchanged
+- API surface unchanged
+- Existing Node.js code continues to work
+
+---
+
 ## What's New in v1.6.0
 
 **Licensing & Builder Identity Scaffolding (Metadata Only)**
@@ -214,6 +240,61 @@ cp -r sdk/codemode your-project/lib/codemode
 
 ---
 
+## Browser Usage (v1.7.0+)
+
+For Vite, React, Next.js, or any browser environment, import from the browser-safe entry:
+
+```typescript
+import {
+  runLoopMode,
+  cancelLoopMode,
+  createP5Runtime,
+  validateCodeModeSource,
+  PROTOCOL_IDENTITY,
+  DEFAULT_CONFIG,
+} from '@nexart/codemode-sdk/browser';
+```
+
+**What's included in `@nexart/codemode-sdk/browser`:**
+- All types (RenderMode, EngineConfig, ExecuteCodeModeInput, etc.)
+- P5 runtime (createP5Runtime, injectTimeVariables, injectProtocolVariables)
+- Loop engine (runLoopMode, cancelLoopMode)
+- Execution sandbox (FORBIDDEN_APIS, createSafeMath)
+- Validation (validateCodeModeSource)
+- Builder manifest (registerBuilderManifest)
+
+**What's NOT included (Node.js only):**
+- `executeCodeMode` — Uses static-engine which requires Node.js canvas
+- `runStaticMode` — Requires Node.js canvas package
+
+For static rendering in browser apps, use your server-side API endpoint.
+
+---
+
+## Node.js Usage (v1.7.0+)
+
+For server-side rendering, oracles, or CLI tools, import from the Node entry:
+
+```typescript
+import {
+  executeCodeMode,
+  runStaticMode,
+  runLoopMode,
+  validateCodeModeSource,
+} from '@nexart/codemode-sdk/node';
+```
+
+**What's included in `@nexart/codemode-sdk/node`:**
+- Everything from the browser entry
+- `executeCodeMode` — Canonical execution API
+- `runStaticMode` — Node.js static rendering (requires `canvas` package)
+
+**Requirements:**
+- Node.js 18+
+- `canvas` package installed for static mode (`npm install canvas`)
+
+---
+
 ## Canonical API
 
 ### `executeCodeMode(input: ExecuteCodeModeInput): Promise<ExecuteCodeModeResult>`
@@ -602,13 +683,18 @@ Ensure your server has this endpoint available (NexArt provides this).
 
 ```
 sdk/codemode/
-├── index.ts          # Main export
+├── entry/
+│   ├── browser.ts    # Browser-safe entry point (v1.7.0)
+│   └── node.ts       # Node.js entry point (v1.7.0)
+├── index.ts          # Main export (app integration layer)
+├── core-index.ts     # Core runtime exports
 ├── execute.ts        # executeCodeMode canonical entry point
 ├── engine.ts         # createEngine entry point (legacy)
 ├── types.ts          # TypeScript types
-├── static-engine.ts  # Static mode implementation
-├── loop-engine.ts    # Loop mode implementation
+├── static-engine.ts  # Static mode implementation (Node.js)
+├── loop-engine.ts    # Loop mode implementation (browser)
 ├── p5-runtime.ts     # p5.js-like runtime
+├── execution-sandbox.ts # Determinism enforcement
 ├── builder-manifest.ts # Builder manifest (write-only)
 ├── CHANGELOG.md      # Version history
 └── README.md         # This file

package/dist/core-index.d.ts

@@ -16,6 +16,6 @@ export { createEngine, } from './engine';
 /**
  * SDK Identity
  */
-export declare const SDK_VERSION = "1.1.1";
+export declare const SDK_VERSION = "1.7.0";
 export declare const SDK_NAME = "@nexart/codemode-sdk";
 //# sourceMappingURL=core-index.d.ts.map

package/dist/core-index.js

@@ -22,5 +22,5 @@ export { createEngine, } from './engine';
 /**
  * SDK Identity
  */
-export const SDK_VERSION = '1.1.1';
+export const SDK_VERSION = '1.7.0';
 export const SDK_NAME = '@nexart/codemode-sdk';

package/dist/entry/browser.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @nexart/codemode-sdk/browser — Browser-Safe Entry Point
+ *
+ * ╔══════════════════════════════════════════════════════════════════════════╗
+ * ║  BROWSER-SAFE SDK ENTRY POINT (v1.7.0)                                   ║
+ * ║                                                                          ║
+ * ║  This entrypoint exports ONLY browser-safe modules.                      ║
+ * ║  It does NOT include static-engine or any Node.js dependencies.          ║
+ * ║                                                                          ║
+ * ║  Use this for Vite, React, Next.js, or any browser environment.          ║
+ * ║                                                                          ║
+ * ║  For Node.js/server: import from '@nexart/codemode-sdk/node'             ║
+ * ╚══════════════════════════════════════════════════════════════════════════╝
+ */
+export type { RenderMode, RuntimeCanvas, EngineConfig, RenderResult, RunOptions, ProgressInfo, Engine, TimeVariables, ProtocolVariables, ProtocolMetadata, ExecuteCodeModeInput, ExecuteCodeModeResult, NexArtBuilderManifest, } from '../types';
+export { PROTOCOL_IDENTITY, DEFAULT_VARS, DEFAULT_CONFIG, } from '../types';
+export { FORBIDDEN_APIS, FORBIDDEN_API_NAMES, createSafeMath, buildSandboxContext, createSandboxedExecutor, executeSandboxed, } from '../execution-sandbox';
+export { createP5Runtime, injectTimeVariables, injectProtocolVariables, createProtocolVAR, VAR_COUNT, VAR_MIN, VAR_MAX, CODE_MODE_PROTOCOL_VERSION, CODE_MODE_PROTOCOL_PHASE, CODE_MODE_ENFORCEMENT, } from '../p5-runtime';
+export type { P5Runtime, P5RuntimeConfig, } from '../p5-runtime';
+export { runLoopMode, cancelLoopMode, } from '../loop-engine';
+export { validateCodeModeSource, } from '../execute';
+export { createEngine, } from '../engine';
+export { registerBuilderManifest, } from '../builder-manifest';
+export declare const SDK_VERSION = "1.7.0";
+export declare const SDK_NAME = "@nexart/codemode-sdk";
+export declare const SDK_ENTRY = "browser";
+/**
+ * Note: executeCodeMode is NOT exported from browser entry.
+ *
+ * In browser environments, static mode requires the canvas package which
+ * has Node.js dependencies. For browser apps:
+ *
+ * - Use runLoopMode() directly for animations
+ * - For static rendering, use the server-side endpoint
+ * - Or import from '@nexart/codemode-sdk/node' in SSR contexts
+ */
+//# sourceMappingURL=browser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../entry/browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;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,eAAO,MAAM,WAAW,UAAU,CAAC;AACnC,eAAO,MAAM,QAAQ,yBAAyB,CAAC;AAC/C,eAAO,MAAM,SAAS,YAAY,CAAC;AAEnC;;;;;;;;;GASG"}

package/dist/entry/browser.js

@@ -0,0 +1,55 @@
+/**
+ * @nexart/codemode-sdk/browser — Browser-Safe Entry Point
+ *
+ * ╔══════════════════════════════════════════════════════════════════════════╗
+ * ║  BROWSER-SAFE SDK ENTRY POINT (v1.7.0)                                   ║
+ * ║                                                                          ║
+ * ║  This entrypoint exports ONLY browser-safe modules.                      ║
+ * ║  It does NOT include static-engine or any Node.js dependencies.          ║
+ * ║                                                                          ║
+ * ║  Use this for Vite, React, Next.js, or any browser environment.          ║
+ * ║                                                                          ║
+ * ║  For Node.js/server: import from '@nexart/codemode-sdk/node'             ║
+ * ╚══════════════════════════════════════════════════════════════════════════╝
+ */
+export { PROTOCOL_IDENTITY, DEFAULT_VARS, DEFAULT_CONFIG, } from '../types';
+// ═══════════════════════════════════════════════════════════════════════════
+// EXECUTION SANDBOX — Browser-safe (no Node dependencies)
+// ═══════════════════════════════════════════════════════════════════════════
+export { FORBIDDEN_APIS, FORBIDDEN_API_NAMES, createSafeMath, buildSandboxContext, createSandboxedExecutor, executeSandboxed, } from '../execution-sandbox';
+// ═══════════════════════════════════════════════════════════════════════════
+// P5 RUNTIME — Browser-safe (DOM-based canvas)
+// ═══════════════════════════════════════════════════════════════════════════
+export { createP5Runtime, injectTimeVariables, injectProtocolVariables, createProtocolVAR, VAR_COUNT, VAR_MIN, VAR_MAX, CODE_MODE_PROTOCOL_VERSION, CODE_MODE_PROTOCOL_PHASE, CODE_MODE_ENFORCEMENT, } from '../p5-runtime';
+// ═══════════════════════════════════════════════════════════════════════════
+// LOOP ENGINE — Browser-safe (uses document.createElement, fetch)
+// ═══════════════════════════════════════════════════════════════════════════
+export { runLoopMode, cancelLoopMode, } from '../loop-engine';
+// ═══════════════════════════════════════════════════════════════════════════
+// VALIDATION — Browser-safe (pure logic)
+// ═══════════════════════════════════════════════════════════════════════════
+export { validateCodeModeSource, } from '../execute';
+// ═══════════════════════════════════════════════════════════════════════════
+// ENGINE FACTORY — Browser-safe wrapper
+// ═══════════════════════════════════════════════════════════════════════════
+export { createEngine, } from '../engine';
+// ═══════════════════════════════════════════════════════════════════════════
+// BUILDER MANIFEST — Browser-safe (data-only, no side effects)
+// ═══════════════════════════════════════════════════════════════════════════
+export { registerBuilderManifest, } from '../builder-manifest';
+// ═══════════════════════════════════════════════════════════════════════════
+// SDK IDENTITY
+// ═══════════════════════════════════════════════════════════════════════════
+export const SDK_VERSION = '1.7.0';
+export const SDK_NAME = '@nexart/codemode-sdk';
+export const SDK_ENTRY = 'browser';
+/**
+ * Note: executeCodeMode is NOT exported from browser entry.
+ *
+ * In browser environments, static mode requires the canvas package which
+ * has Node.js dependencies. For browser apps:
+ *
+ * - Use runLoopMode() directly for animations
+ * - For static rendering, use the server-side endpoint
+ * - Or import from '@nexart/codemode-sdk/node' in SSR contexts
+ */

package/dist/entry/node.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @nexart/codemode-sdk/node — Node.js Entry Point
+ *
+ * ╔══════════════════════════════════════════════════════════════════════════╗
+ * ║  NODE.JS SDK ENTRY POINT (v1.7.0)                                        ║
+ * ║                                                                          ║
+ * ║  This entrypoint exports Node.js-specific modules that require:          ║
+ * ║  - canvas package (node-canvas)                                          ║
+ * ║  - Node.js built-ins (module, fs, path)                                  ║
+ * ║                                                                          ║
+ * ║  Use this for server-side rendering, oracles, or CLI tools.              ║
+ * ║                                                                          ║
+ * ║  For browser/Vite: import from '@nexart/codemode-sdk/browser'            ║
+ * ╚══════════════════════════════════════════════════════════════════════════╝
+ */
+export * from './browser';
+export { runStaticMode, } from '../static-engine';
+export { executeCodeMode, } from '../execute';
+export { SDK_VERSION, SDK_NAME } from './browser';
+export declare const SDK_ENTRY = "node";
+//# sourceMappingURL=node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../entry/node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;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/entry/node.js

@@ -0,0 +1,32 @@
+/**
+ * @nexart/codemode-sdk/node — Node.js Entry Point
+ *
+ * ╔══════════════════════════════════════════════════════════════════════════╗
+ * ║  NODE.JS SDK ENTRY POINT (v1.7.0)                                        ║
+ * ║                                                                          ║
+ * ║  This entrypoint exports Node.js-specific modules that require:          ║
+ * ║  - canvas package (node-canvas)                                          ║
+ * ║  - Node.js built-ins (module, fs, path)                                  ║
+ * ║                                                                          ║
+ * ║  Use this for server-side rendering, oracles, or CLI tools.              ║
+ * ║                                                                          ║
+ * ║  For browser/Vite: import from '@nexart/codemode-sdk/browser'            ║
+ * ╚══════════════════════════════════════════════════════════════════════════╝
+ */
+// ═══════════════════════════════════════════════════════════════════════════
+// RE-EXPORT ALL BROWSER-SAFE MODULES
+// ═══════════════════════════════════════════════════════════════════════════
+export * from './browser';
+// ═══════════════════════════════════════════════════════════════════════════
+// STATIC ENGINE — Node.js only (requires canvas package)
+// ═══════════════════════════════════════════════════════════════════════════
+export { runStaticMode, } from '../static-engine';
+// ═══════════════════════════════════════════════════════════════════════════
+// CANONICAL EXECUTION — Node.js only (imports static-engine)
+// ═══════════════════════════════════════════════════════════════════════════
+export { executeCodeMode, } from '../execute';
+// ═══════════════════════════════════════════════════════════════════════════
+// SDK IDENTITY (override browser entry)
+// ═══════════════════════════════════════════════════════════════════════════
+export { SDK_VERSION, SDK_NAME } from './browser';
+export const SDK_ENTRY = 'node';

package/dist/index.d.ts

@@ -1,50 +1,31 @@
 /**
- * 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'
- * ```
  */
-export { executeCodeMode, validateCodeModeSource } from './execute';
-export type { ExecuteCodeModeInput, ExecuteCodeModeResult, ProtocolMetadata, } from './types';
-export { PROTOCOL_IDENTITY } from './types';
+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, RenderResult, ProgressInfo, RenderMode, TimeVariables, } from './types';
-export { DEFAULT_CONFIG } from './types';
+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 { createP5Runtime, type P5Runtime, type P5RuntimeConfig } from './p5-runtime';
 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 +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/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"}