@nexart/codemode-sdk 1.5.1 → 1.7.0

package/CHANGELOG.md

@@ -4,6 +4,84 @@ 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
+
+**Non-Breaking, Metadata-Only Release**
+
+This release introduces scaffolding for future licensing and builder identity features. All additions are informational only — no behavior changes, no enforcement, no runtime validation.
+
+#### Licensing (Informational Only)
+- **LICENSE.md**: Draft commercial licensing terms with enforcement NOT active
+- README section: "Commercial usage of NexArt Protocol requires a license. Enforcement is not active yet."
+
+#### Builder Manifest Schema (Optional)
+- **builder.manifest.schema.json**: JSON schema for optional builder attribution
+- Fields: `builder_id`, `project_name`, `contact`, `website`, `intended_use`
+- NOT validated, NOT loaded at runtime, NOT required
+
+#### Documentation
+- Positioned SDK as "canonical execution surface"
+- Explained determinism guarantees explicitly
+- Referenced real products (ByX, Frontierra)
+
+### Unchanged
+
+- No changes to execution or determinism
+- No changes to protocol version (remains v1.2.0)
+- No runtime validation or enforcement
+- No new required files or dependencies
+- Full backward compatibility with v1.5.x
+- Existing sketches run unchanged
+
+### Verification
+
+Run `npx tsx scripts/check-determinism.ts` — must pass before release.
+
+---
+
 ## [1.5.1] — 2026-01-05
 
 ### Added

package/LICENSE.md

@@ -0,0 +1,62 @@
+NexArt Code Mode SDK — License
+
+Version: 1.6.0
+Status: DRAFT — Enforcement Not Active
+
+⸻
+
+License Status
+
+The NexArt Code Mode SDK is currently released under the MIT License.
+
+At this time, all usage — including commercial usage — is permitted under the MIT License.
+
+This document also serves as advance notice of a future commercial licensing model that may apply to certain uses of the NexArt Protocol.
+
+⸻
+
+Future Commercial Licensing (Not Active)
+
+NexArt intends to introduce a separate commercial license for specific categories of usage in a future release.
+
+Planned commercial usage categories may include (non-exhaustive):
+	•	Minting NFTs for sale
+	•	Revenue-generating applications
+	•	Products or services that charge fees
+	•	Enterprise or business deployments
+
+Enforcement is NOT active.
+
+No license keys, validation, usage tracking, or commercial restrictions are currently implemented.
+
+Until enforcement is introduced in a future version, all usage remains governed solely by the MIT License below.
+
+⸻
+
+MIT License
+
+Copyright (c) 2024–2026 NexArt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+⸻
+
+Contact
+
+For future commercial licensing inquiries: arrotu@artnames.io

package/README.md

@@ -1,16 +1,15 @@
 # NexArt Code Mode Runtime SDK
 
-**Version: 1.5.1 (Protocol v1.2.0)**
+**Version: 1.7.0 (Protocol v1.2.0)**
 
 ╔══════════════════════════════════════════════════════════════════════════════╗
-║  @nexart/codemode-sdk — Canonical Code Mode Authority                        ║
+║  @nexart/codemode-sdk — Canonical Execution Surface                          ║
 ║                                                                              ║
-║  This SDK defines the official Code Mode execution surface.                  ║
-║  All implementations (NexArt, ByX, external) MUST use this SDK.              ║
+║  This SDK IS the protocol. All implementations MUST use this SDK.            ║
 ║                                                                              ║
 ║  Protocol: nexart                                                            ║
 ║  Engine: codemode                                                            ║
-║  SDK Version: 1.5.1                                                          ║
+║  SDK Version: 1.7.0                                                          ║
 ║  Protocol Version: 1.2.0                                                     ║
 ║  Phase: 3                                                                    ║
 ║  Enforcement: HARD                                                           ║
@@ -18,6 +17,15 @@
 
 ---
 
+## Commercial Licensing
+
+> **Commercial usage of NexArt Protocol requires a license.**
+> **Enforcement is not active yet.**
+
+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.
+
+---
+
 ## PROTOCOL LOCK — v1.x
 
 | Property | Value |
@@ -54,32 +62,111 @@ The answer is: "Whatever @nexart/codemode-sdk does — that is the protocol."
 
 ---
 
-## What's New in v1.5.1
+## What's New in v1.7.0
 
-**Builder Manifest — Passive Attribution (Write-Only)**
+**Browser-Safe Entrypoint + Conditional Exports**
 
-- `registerBuilderManifest(manifest?)` — Declare builder identity for future attribution
+This release makes the SDK reliably usable in browser environments (Vite/React) without any Node.js dependency leakage.
 
-**The Builder Manifest is a declaration of intent, not a capability.**
+### 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)
 
-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
+### 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
 
-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.
+### 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
 
-```typescript
-import { registerBuilderManifest } from '@nexart/codemode-sdk';
+### No Breaking Changes
+- Protocol behavior and determinism unchanged
+- API surface unchanged
+- Existing Node.js code continues to work
 
-registerBuilderManifest({
-  protocol: 'nexart',
-  manifestVersion: '0.1',
-  app: { name: 'My App', url: 'https://myapp.com' }
-});
+---
+
+## What's New in v1.6.0
+
+**Licensing & Builder Identity Scaffolding (Metadata Only)**
+
+This is a non-breaking, metadata-only release. No changes to execution or determinism.
+
+### Licensing (Informational Only)
+- Added `LICENSE.md` with draft commercial licensing terms
+- Enforcement is NOT active — all usage currently permitted under MIT
+
+### Builder Manifest Schema
+- Added `builder.manifest.schema.json` for optional builder attribution
+- Fields: `builder_id`, `project_name`, `contact`, `website`, `intended_use`
+- This file is **optional**, **not validated**, and **not loaded at runtime**
+
+### Documentation
+- SDK positioned as "canonical execution surface"
+- Explicit determinism guarantees documented
+- Real product references (ByX, Frontierra)
+
+---
+
+## Determinism Guarantees
+
+**The NexArt Code Mode SDK guarantees deterministic output.**
+
+Given identical inputs:
+- Same `source` code
+- Same `seed`
+- Same `vars` array
+- Same `width` and `height`
+- Same `mode`
+
+The SDK will produce **byte-for-byte identical output** across all executions.
+
+### What Breaks Determinism
+
+The following actions will break determinism and are **blocked** by the SDK:
+
+| Pattern | Reason | Enforcement |
+|---------|--------|-------------|
+| `Math.random()` | Unseeded randomness | BLOCKED |
+| `Date.now()` | Time-based entropy | BLOCKED |
+| `new Date()` | Time-based entropy | BLOCKED |
+| `performance.now()` | Timing entropy | BLOCKED |
+| `crypto.getRandomValues()` | Crypto randomness | BLOCKED |
+| `fetch()` | External IO | BLOCKED |
+| External imports | Uncontrolled code | BLOCKED |
+
+Use `random()` (seeded) and `noise()` (seeded) for all randomness needs.
+
+### Oracle Verification
+
+Before any release, run the determinism check:
+
+```bash
+npx tsx scripts/check-determinism.ts
 ```
 
+This compares output against a known oracle hash. If the hash changes without a protocol version bump, the release is invalid.
+
+---
+
+## Products Using This SDK
+
+- **NexArt**: Primary generative art platform
+- **ByX**: Curated collection system
+- **Frontierra**: External builder integration
+
+---
+
+## v1.5.1
+
+**Builder Manifest — Passive Attribution (Write-Only)**
+
+- `registerBuilderManifest(manifest?)` — Declare builder identity for future attribution
+
+The Builder Manifest is a declaration of intent, not a capability. Write-only, optional, non-enforced.
+
 ---
 
 ## v1.4.0 (Protocol v1.2.0)
@@ -153,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>`
@@ -541,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/builder.manifest.schema.json

@@ -0,0 +1,62 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://nexart.art/schemas/builder.manifest.json",
+  "title": "NexArt Builder Manifest",
+  "description": "Optional metadata file for builder attribution. NOT validated, NOT required, NOT enforced.",
+  "type": "object",
+  "properties": {
+    "protocol": {
+      "type": "string",
+      "const": "nexart",
+      "description": "Protocol identifier (must be 'nexart')"
+    },
+    "manifest_version": {
+      "type": "string",
+      "description": "Version of this manifest schema",
+      "default": "1.0"
+    },
+    "builder_id": {
+      "type": "string",
+      "description": "Unique identifier for the builder (self-assigned)"
+    },
+    "project_name": {
+      "type": "string",
+      "description": "Name of the project or application"
+    },
+    "description": {
+      "type": "string",
+      "description": "Brief description of the project"
+    },
+    "contact": {
+      "type": "string",
+      "description": "Contact email or handle"
+    },
+    "website": {
+      "type": "string",
+      "format": "uri",
+      "description": "Project website URL"
+    },
+    "intended_use": {
+      "type": "string",
+      "enum": ["art", "game", "research", "commercial", "education", "other"],
+      "description": "Primary intended use case"
+    },
+    "sdk_version": {
+      "type": "string",
+      "description": "Version of @nexart/codemode-sdk being used"
+    },
+    "features": {
+      "type": "object",
+      "description": "Optional feature flags",
+      "additionalProperties": {
+        "type": "boolean"
+      }
+    },
+    "metadata": {
+      "type": "object",
+      "description": "Arbitrary additional metadata",
+      "additionalProperties": true
+    }
+  },
+  "additionalProperties": true
+}

package/dist/builder-manifest.d.ts

@@ -1,6 +1,6 @@
 /**
  * NexArt Code Mode SDK - Builder Manifest
- * Version: 1.5.1 (Protocol v1.2.0)
+ * Version: 1.6.0 (Protocol v1.2.0)
  *
  * ╔══════════════════════════════════════════════════════════════════════════╗
  * ║  BUILDER MANIFEST — PASSIVE ATTRIBUTION (WRITE-ONLY)                     ║

package/dist/builder-manifest.js

@@ -1,6 +1,6 @@
 /**
  * NexArt Code Mode SDK - Builder Manifest
- * Version: 1.5.1 (Protocol v1.2.0)
+ * Version: 1.6.0 (Protocol v1.2.0)
  *
  * ╔══════════════════════════════════════════════════════════════════════════╗
  * ║  BUILDER MANIFEST — PASSIVE ATTRIBUTION (WRITE-ONLY)                     ║

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';