@nexart/codemode-sdk 1.6.0 → 1.8.0

package/CHANGELOG.md

@@ -4,6 +4,107 @@ All notable changes to @nexart/codemode-sdk will be documented in this file.
 
 ---
 
+## [1.8.0] — 2026-01-24
+
+### Added — Agent-First Runtime Authority Layer
+
+**Additive, Non-Breaking Release**
+
+This release introduces `createRuntime()` — an agent-first API designed for AI coding assistants (Replit, Lovable, Claude Code) to reliably execute deterministic code without rolling their own PRNG/noise implementations.
+
+#### New Runtime API (`createRuntime`)
+- **`createRuntime(options)`** — Create a deterministic runtime instance
+  - `seed: string | number` — Seed for deterministic randomness
+  - `vars?: number[]` — VAR array (0-100 inputs), defaults to zeros
+  - `strict?: boolean` — Enable strict mode (default: false)
+  - `mode?: 'static' | 'loop'` — Execution mode (default: 'static')
+  - `metadata?: Record<string, any>` — Optional user metadata for digest
+
+#### Runtime Methods
+- **`random(): number`** — Deterministic random [0, 1) using Mulberry32
+- **`randomInt(min, max): number`** — Deterministic integer in range
+- **`randomRange(min, max): number`** — Deterministic float in range
+- **`noise(x, y?, z?): number`** — Deterministic Perlin noise
+- **`run(fn): T`** — Execute code with optional strict enforcement
+- **`digest(): string`** — Stable hash for verification (FNV-1a)
+- **`getState(): RuntimeState`** — Canonical state snapshot for replay
+
+#### Strict Mode Enforcement
+When `strict: true`, the runtime intercepts non-deterministic APIs during `run()`:
+- `Math.random` → Throws with actionable error message
+- `Date.now` → Throws with actionable error message  
+- `performance.now` → Throws with actionable error message
+
+Error format: `NEXART_STRICT: Non-deterministic API used: {api}. {guidance}`
+
+#### Documentation Updates
+- Added "For AI Coding Agents" section at top of README
+- Added "Determinism Contract" with ✅/❌ checklist
+- Added "Why Not Just Use a PRNG?" comparison table
+- Added "Environment Imports" matrix
+- Simplified license section for clarity
+
+#### Examples
+- `examples/basic.ts` — Basic usage demonstration
+- `examples/verify.ts` — Determinism verification tests
+- `npm run example:basic` — Run basic example
+- `npm run example:verify` — Run verification tests
+
+#### Package Updates
+- Added keywords: deterministic, reproducible, verifiable, replay, canonical, simulation, procedural, seed, prng, ai-agent, strict-mode
+- Updated description for agent discoverability
+
+### Unchanged
+
+- No changes to protocol behavior or determinism
+- No changes to protocol version (remains v1.2.0)
+- No changes to existing APIs (executeCodeMode, createEngine, etc.)
+- Default import remains browser-safe
+- Full backward compatibility with v1.7.x
+
+---
+
+## [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.8.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.8.0                                                          ║
 ║  Protocol Version: 1.2.0                                                     ║
 ║  Phase: 3                                                                    ║
 ║  Enforcement: HARD                                                           ║
@@ -17,12 +17,90 @@
 
 ---
 
-## Commercial Licensing
+## For AI Coding Agents (Replit / Lovable / Claude Code)
 
-> **Commercial usage of NexArt Protocol requires a license.**
-> **Enforcement is not active yet.**
+**ALWAYS use `createRuntime({ seed, strict: true })` for deterministic execution.**
 
-The SDK is currently provided under the MIT License for all usage. A future version may introduce commercial licensing requirements. See [LICENSE.md](./LICENSE.md) for details.
+```typescript
+import { createRuntime } from "@nexart/codemode-sdk";
+
+const runtime = createRuntime({
+  seed: "my-artwork-42",
+  vars: [50, 75, 25],
+  strict: true,  // IMPORTANT: Throws on Math.random, Date.now, etc.
+  mode: "static"
+});
+
+// Use runtime.random() instead of Math.random()
+const value = runtime.random();          // Deterministic [0, 1)
+const intVal = runtime.randomInt(0, 10); // Deterministic integer
+const n = runtime.noise(x, y);           // Deterministic Perlin noise
+
+// Verify determinism
+console.log(runtime.digest());  // Stable hash for verification
+console.log(runtime.getState()); // Canonical state snapshot
+```
+
+**Strict mode throws actionable errors:**
+- `NEXART_STRICT: Non-deterministic API used: Math.random. Use runtime.random() instead.`
+- `NEXART_STRICT: Non-deterministic API used: Date.now. Pass time as an input or use deterministic counters.`
+- `NEXART_STRICT: Non-deterministic API used: performance.now.`
+
+---
+
+## Determinism Contract
+
+✅ **Guaranteed:**
+- Same `sdkVersion` + `seed` + `vars` → identical output
+- Cross-environment stable digest (browser, Node.js, CI)
+- Seeded PRNG via `runtime.random()` (Mulberry32)
+- Seeded noise via `runtime.noise()` (Perlin)
+
+❌ **Forbidden (blocked in strict mode):**
+- `Math.random()` — use `runtime.random()` instead
+- `Date.now()` — pass time as input or use frame counters
+- `performance.now()` — use deterministic timing
+- External IO during deterministic runs (not supported)
+
+---
+
+## Why Not Just Use a PRNG?
+
+| Feature | Plain PRNG | NexArt Runtime |
+|---------|-----------|----------------|
+| Seeded random | ✅ | ✅ |
+| Seeded noise | ❌ (separate lib) | ✅ built-in |
+| Strict mode (blocks entropy) | ❌ | ✅ |
+| Canonical state snapshot | ❌ | ✅ `getState()` |
+| Cross-env stable digest | ❌ | ✅ `digest()` |
+| VAR protocol (0-100 inputs) | ❌ | ✅ |
+| Replay/verification | Manual | Built-in |
+| Error messages for agents | ❌ | ✅ actionable |
+
+**The runtime provides a complete determinism layer, not just random numbers.**
+
+---
+
+## Environment Imports
+
+| Environment | Import Path |
+|-------------|-------------|
+| Browser / Vite / Next.js / React | `import { createRuntime } from "@nexart/codemode-sdk"` |
+| Node.js (general use) | `import { createRuntime } from "@nexart/codemode-sdk"` |
+| Node.js server rendering (canvas) | `import { executeCodeMode } from "@nexart/codemode-sdk/node"` |
+
+**The default import is always browser-safe.** Node-only features (`executeCodeMode`, `runStaticMode`) require explicit `/node` import.
+
+---
+
+## License
+
+**Free for:**
+- Experiments and prototypes
+- Personal projects
+- Open-source projects
+
+**Commercial production deployments require a license.** See [LICENSING.md](./LICENSING.md) for details.
 
 ---
 
@@ -62,6 +140,80 @@ The answer is: "Whatever @nexart/codemode-sdk does — that is the protocol."
 
 ---
 
+## What's New in v1.8.0
+
+**Agent-First Runtime Authority Layer**
+
+This release introduces `createRuntime()` — an agent-first API designed for AI coding assistants to reliably execute deterministic code.
+
+### New Runtime API
+```typescript
+import { createRuntime } from "@nexart/codemode-sdk";
+
+const runtime = createRuntime({
+  seed: "my-seed",
+  vars: [50, 75],
+  strict: true,
+  mode: "static",
+  metadata: { artist: "demo" }
+});
+
+runtime.random();           // Deterministic PRNG
+runtime.randomInt(0, 100);  // Deterministic integer
+runtime.noise(x, y, z);     // Deterministic Perlin noise
+runtime.digest();           // Stable hash for verification
+runtime.getState();         // Canonical state snapshot
+runtime.run(() => { ... }); // Execute with strict enforcement
+```
+
+### Strict Mode
+- Throws actionable errors on `Math.random`, `Date.now`, `performance.now`
+- Only applies during `runtime.run()` — non-invasive
+- Error messages guide agents to correct usage
+
+### Agent-First Documentation
+- "For AI Coding Agents" section at top of README
+- Determinism Contract with ✅/❌ checklist
+- PRNG comparison table
+- Environment import matrix
+
+### Examples
+- `npm run example:basic` — Basic usage demonstration
+- `npm run example:verify` — Determinism verification tests
+
+### No Breaking Changes
+- All existing APIs work unchanged
+- Default import remains browser-safe
+- Protocol version unchanged (v1.2.0)
+
+---
+
+## 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 +366,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 +809,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.8.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.8.0';
 export const SDK_NAME = '@nexart/codemode-sdk';

package/dist/entry/browser.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @nexart/codemode-sdk/browser — Browser-Safe Entry Point
+ *
+ * ╔══════════════════════════════════════════════════════════════════════════╗
+ * ║  BROWSER-SAFE SDK ENTRY POINT (v1.8.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'             ║
+ * ║                                                                          ║
+ * ║  AI AGENTS: Start with createRuntime({ seed, strict: true })             ║
+ * ╚══════════════════════════════════════════════════════════════════════════╝
+ */
+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 { createRuntime, NexArtRuntime, RUNTIME_VERSION, } from '../runtime';
+export type { RuntimeOptions, RuntimeState, NexArtRuntime as NexArtRuntimeType, } from '../runtime';
+export declare const SDK_VERSION = "1.8.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
+ *
+ * AI AGENTS: Use createRuntime({ seed, strict: true }) for deterministic execution.
+ */
+//# 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;;;;;;;;;;;;;;;GAeG;AAKH,YAAY,EACV,UAAU,EACV,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,MAAM,EACN,aAAa,EACb,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,cAAc,GACf,MAAM,UAAU,CAAC;AAKlB,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAK9B,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,uBAAuB,EACvB,iBAAiB,EACjB,SAAS,EACT,OAAO,EACP,OAAO,EACP,0BAA0B,EAC1B,wBAAwB,EACxB,qBAAqB,GACtB,MAAM,eAAe,CAAC;AAEvB,YAAY,EACV,SAAS,EACT,eAAe,GAChB,MAAM,eAAe,CAAC;AAKvB,OAAO,EACL,WAAW,EACX,cAAc,GACf,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EACL,sBAAsB,GACvB,MAAM,YAAY,CAAC;AAKpB,OAAO,EACL,YAAY,GACb,MAAM,WAAW,CAAC;AAKnB,OAAO,EACL,uBAAuB,GACxB,MAAM,qBAAqB,CAAC;AAK7B,OAAO,EACL,aAAa,EACb,aAAa,EACb,eAAe,GAChB,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,cAAc,EACd,YAAY,EACZ,aAAa,IAAI,iBAAiB,GACnC,MAAM,YAAY,CAAC;AAKpB,eAAO,MAAM,WAAW,UAAU,CAAC;AACnC,eAAO,MAAM,QAAQ,yBAAyB,CAAC;AAC/C,eAAO,MAAM,SAAS,YAAY,CAAC;AAEnC;;;;;;;;;;;GAWG"}

package/dist/entry/browser.js

@@ -0,0 +1,63 @@
+/**
+ * @nexart/codemode-sdk/browser — Browser-Safe Entry Point
+ *
+ * ╔══════════════════════════════════════════════════════════════════════════╗
+ * ║  BROWSER-SAFE SDK ENTRY POINT (v1.8.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'             ║
+ * ║                                                                          ║
+ * ║  AI AGENTS: Start with createRuntime({ seed, strict: true })             ║
+ * ╚══════════════════════════════════════════════════════════════════════════╝
+ */
+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';
+// ═══════════════════════════════════════════════════════════════════════════
+// AGENT-FIRST RUNTIME — v1.8.0 (Browser-safe, no Node dependencies)
+// ═══════════════════════════════════════════════════════════════════════════
+export { createRuntime, NexArtRuntime, RUNTIME_VERSION, } from '../runtime';
+// ═══════════════════════════════════════════════════════════════════════════
+// SDK IDENTITY
+// ═══════════════════════════════════════════════════════════════════════════
+export const SDK_VERSION = '1.8.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
+ *
+ * AI AGENTS: Use createRuntime({ seed, strict: true }) for deterministic execution.
+ */

package/dist/entry/node.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @nexart/codemode-sdk/node — Node.js Entry Point
+ *
+ * ╔══════════════════════════════════════════════════════════════════════════╗
+ * ║  NODE.JS SDK ENTRY POINT (v1.8.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'            ║
+ * ║                                                                          ║
+ * ║  AI AGENTS: Start with createRuntime({ seed, strict: true })             ║
+ * ╚══════════════════════════════════════════════════════════════════════════╝
+ */
+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;;;;;;;;;;;;;;;;GAgBG;AAKH,cAAc,WAAW,CAAC;AAK1B,OAAO,EACL,aAAa,GACd,MAAM,kBAAkB,CAAC;AAK1B,OAAO,EACL,eAAe,GAChB,MAAM,YAAY,CAAC;AAKpB,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAClD,eAAO,MAAM,SAAS,SAAS,CAAC"}

package/dist/entry/node.js

@@ -0,0 +1,34 @@
+/**
+ * @nexart/codemode-sdk/node — Node.js Entry Point
+ *
+ * ╔══════════════════════════════════════════════════════════════════════════╗
+ * ║  NODE.JS SDK ENTRY POINT (v1.8.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'            ║
+ * ║                                                                          ║
+ * ║  AI AGENTS: Start with createRuntime({ seed, strict: true })             ║
+ * ╚══════════════════════════════════════════════════════════════════════════╝
+ */
+// ═══════════════════════════════════════════════════════════════════════════
+// 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