@json-eval-rs/webcore 0.0.29

package/README.md

@@ -0,0 +1,139 @@
+# @json-eval-rs/webcore
+
+High-level JavaScript API for JSON Eval RS WASM bindings.
+
+## Installation
+
+```bash
+# Install bridge + your target WASM package
+yarn install @json-eval-rs/webcore @json-eval-rs/bundler
+
+# Or for direct browser use
+yarn install @json-eval-rs/webcore @json-eval-rs/vanilla
+
+# Or for Node.js
+yarn install @json-eval-rs/webcore @json-eval-rs/node
+```
+
+## Usage
+
+### With Bundler (Webpack, Vite, Next.js, etc.)
+
+```typescript
+import { JSONEval } from '@json-eval-rs/webcore';
+import * as wasmModule from '@json-eval-rs/bundler';
+
+const evaluator = new JSONEval({
+  schema: {
+    type: 'object',
+    properties: {
+      name: {
+        type: 'string',
+        rules: {
+          required: { value: true, message: 'Name is required' },
+          minLength: { value: 3, message: 'Min 3 characters' }
+        }
+      }
+    }
+  },
+  wasmModule // Pass the WASM module explicitly
+});
+
+// Validate data
+const result = await evaluator.validate({
+  data: { name: 'Jo' }
+});
+
+if (result.has_error) {
+  console.log('Errors:', result.errors);
+}
+
+// Don't forget to free resources
+evaluator.free();
+```
+
+### Dynamic Import (for Next.js client components)
+
+```typescript
+'use client';
+
+useEffect(() => {
+  Promise.all([
+    import('@json-eval-rs/webcore'),
+    import('@json-eval-rs/bundler')
+  ]).then(([{ JSONEval }, wasmModule]) => {
+    const evaluator = new JSONEval({ schema, wasmModule });
+    // Use evaluator...
+  });
+}, []);
+```
+
+### API
+
+#### `new JSONEval(options)`
+
+Create a new evaluator instance.
+
+**Options:**
+- `schema` (required) - JSON schema object
+- `context` (optional) - Context data object
+- `data` (optional) - Initial data object
+- `wasmModule` (optional) - Pre-loaded WASM module
+
+#### `await evaluator.validate({ data, context? })`
+
+Validate data against schema rules.
+
+Returns: `{ has_error: boolean, errors: ValidationError[] }`
+
+#### `await evaluator.evaluate({ data, context? })`
+
+Evaluate schema with data.
+
+Returns: Evaluated schema object
+
+#### `await evaluator.evaluateDependents({ changedPaths, data, context?, nested? })`
+
+Re-evaluate fields that depend on changed paths.
+
+**Options:**
+- `changedPaths` - Array of field paths that changed
+- `data` - Current data
+- `context` (optional) - Context data
+- `nested` (optional, default: true) - Follow dependency chains
+
+Returns: Updated evaluated schema
+
+#### `evaluator.free()`
+
+Free WASM resources. Call this when done.
+
+## Why Use the Core?
+
+The core package provides:
+
+1. **Clean API** - Options objects instead of positional JSON strings
+2. **Type Safety** - Full TypeScript support
+3. **Auto-detection** - Automatically loads the right WASM target
+4. **Flexibility** - Works with bundler/web/node targets
+
+## Direct WASM Usage
+
+If you prefer minimal overhead, you can use WASM packages directly:
+
+```typescript
+import { JSONEvalWasm } from '@json-eval-rs/bundler';
+
+const instance = new JSONEvalWasm(
+  JSON.stringify(schema),
+  JSON.stringify(context),
+  JSON.stringify(data)
+);
+
+const result = await instance.validate(JSON.stringify(data));
+instance.free();
+```
+
+## License
+
+MIT

package/index.d.ts

@@ -0,0 +1,368 @@
+/**
+ * @json-eval-rs/webcore - TypeScript definitions
+ */
+
+/**
+ * Get the library version from the WASM module
+ * @param wasmModule - WASM module
+ * @returns Version string
+ */
+export function getVersion(wasmModule: any): string;
+
+/**
+ * Return format for path-based methods
+ */
+export enum ReturnFormat {
+  /** Nested object preserving the path hierarchy (default) */
+  Nested = 0,
+  /** Flat object with dotted keys */
+  Flat = 1,
+  /** Array of values in the order of requested paths */
+  Array = 2
+}
+
+/**
+ * Validation error for a specific field
+ */
+export interface ValidationError {
+  /** Field path with the error */
+  path: string;
+  /** Type of validation rule that failed (e.g., 'required', 'min', 'max', 'pattern') */
+  rule_type: string;
+  /** Error message */
+  message: string;
+  /** Optional error code */
+  code?: string;
+  /** Optional regex pattern (for pattern validation errors) */
+  pattern?: string;
+  /** Optional field value that failed validation (as string) */
+  field_value?: string;
+  /** Optional additional data context for the error */
+  data?: any;
+}
+
+/**
+ * Result of validation operation
+ */
+export interface ValidationResult {
+  /** Whether any validation errors occurred */
+  has_error: boolean;
+  /** Array of validation errors */
+  errors: ValidationError[];
+}
+
+/**
+ * Dependent field change from evaluateDependents
+ */
+export interface DependentChange {
+  /** Path of the dependent field (in dot notation) */
+  $ref: string;
+  /** Schema definition of the changed field */
+  $field?: any;
+  /** Schema definition of the parent field */
+  $parentField: any;
+  /** Whether this is a transitive dependency */
+  transitive: boolean;
+  /** If true, the field was cleared */
+  clear?: boolean;
+  /** New value of the field (if changed) */
+  value?: any;
+}
+
+/**
+ * Options for creating a JSONEval instance
+ */
+export interface JSONEvalOptions {
+  /** JSON schema object */
+  schema: any;
+  /** Optional context data */
+  context?: any;
+  /** Optional initial data */
+  data?: any;
+  /** WASM module instance */
+  wasmModule?: any;
+}
+
+/**
+ * Options for validation
+ */
+export interface ValidateOptions {
+  /** JSON data to validate */
+  data: any;
+  /** Optional context data */
+  context?: any;
+}
+
+/**
+ * Options for evaluation
+ */
+export interface EvaluateOptions {
+  /** JSON data to evaluate */
+  data: any;
+  /** Optional context data */
+  context?: any;
+}
+
+/**
+ * Options for evaluating dependents
+ */
+export interface EvaluateDependentsOptions {
+  /** Array of field paths that changed */
+  changedPaths: string[];
+  /** Updated JSON data */
+  data?: any;
+  /** Optional context data */
+  context?: any;
+  /** If true, performs full evaluation after processing dependents */
+  reEvaluate?: boolean;
+}
+
+/**
+ * Options for getting evaluated schema
+ */
+export interface GetEvaluatedSchemaOptions {
+  /** Whether to skip layout resolution */
+  skipLayout?: boolean;
+}
+
+/**
+ * Options for getting a value by path from evaluated schema
+ */
+export interface GetValueByPathOptions {
+  /** Dotted path to the value */
+  path: string;
+  /** Whether to skip layout resolution */
+  skipLayout?: boolean;
+}
+
+/**
+ * Options for getting values by multiple paths from evaluated schema
+ */
+export interface GetValueByPathsOptions {
+  /** Array of dotted paths to retrieve */
+  paths: string[];
+  /** Whether to skip layout resolution */
+  skipLayout?: boolean;
+  /** Return format (Nested, Flat, or Array) */
+  format?: ReturnFormat;
+}
+
+/**
+ * Options for getting a value by path from schema
+ */
+export interface GetSchemaByPathOptions {
+  /** Dotted path to the value */
+  path: string;
+}
+
+/**
+ * Options for getting values by multiple paths from schema
+ */
+export interface GetSchemaByPathsOptions {
+  /** Array of dotted paths to retrieve */
+  paths: string[];
+  /** Return format (Nested, Flat, or Array) */
+  format?: ReturnFormat;
+}
+
+/**
+ * Options for reloading schema
+ */
+export interface ReloadSchemaOptions {
+  /** New JSON schema */
+  schema: any;
+  /** Optional new context */
+  context?: any;
+  /** Optional new data */
+  data?: any;
+}
+
+/**
+ * Cache statistics
+ */
+export interface CacheStats {
+  /** Number of cache hits */
+  hits: number;
+  /** Number of cache misses */
+  misses: number;
+  /** Number of cached entries */
+  entries: number;
+}
+
+/**
+ * Options for evaluating a subform
+ */
+export interface EvaluateSubformOptions {
+  /** Path to the subform */
+  subformPath: string;
+  /** JSON data to evaluate */
+  data: any;
+  /** Optional context data */
+  context?: any;
+}
+
+/**
+ * Options for validating a subform
+ */
+export interface ValidateSubformOptions {
+  /** Path to the subform */
+  subformPath: string;
+  /** JSON data to validate */
+  data: any;
+  /** Optional context data */
+  context?: any;
+}
+
+/**
+ * Options for evaluating dependents in a subform
+ */
+export interface EvaluateDependentsSubformOptions {
+  /** Path to the subform */
+  subformPath: string;
+  /** Array of field paths that changed */
+  changedPaths: string[];
+  /** Updated JSON data */
+  data?: any;
+  /** Optional context data */
+  context?: any;
+  /** If true, performs full evaluation after processing dependents */
+  reEvaluate?: boolean;
+}
+
+/**
+ * Options for resolving layout in a subform
+ */
+export interface ResolveLayoutSubformOptions {
+  /** Path to the subform */
+  subformPath: string;
+  /** Whether to evaluate after resolving layout */
+  evaluate?: boolean;
+}
+
+/**
+ * Options for getting evaluated schema from a subform
+ */
+export interface GetEvaluatedSchemaSubformOptions {
+  /** Path to the subform */
+  subformPath: string;
+  /** Whether to resolve layout */
+  resolveLayout?: boolean;
+}
+
+/**
+ * Options for getting schema value from a subform
+ */
+export interface GetSchemaValueSubformOptions {
+  /** Path to the subform */
+  subformPath: string;
+}
+
+/**
+ * Options for getting evaluated schema by path from a subform
+ */
+export interface GetEvaluatedSchemaByPathSubformOptions {
+  /** Path to the subform */
+  subformPath: string;
+  /** Dotted path to the value within the subform */
+  schemaPath: string;
+  /** Whether to skip layout resolution */
+  skipLayout?: boolean;
+}
+
+/**
+ * Options for getting evaluated schema by multiple paths from a subform
+ */
+export interface GetEvaluatedSchemaByPathsSubformOptions {
+  /** Path to the subform */
+  subformPath: string;
+  /** Array of dotted paths to retrieve within the subform */
+  schemaPaths: string[];
+  /** Whether to skip layout resolution */
+  skipLayout?: boolean;
+  /** Return format (Nested, Flat, or Array) */
+  format?: ReturnFormat;
+}
+
+/**
+ * Options for getting schema by path from a subform
+ */
+export interface GetSchemaByPathSubformOptions {
+  /** Path to the subform */
+  subformPath: string;
+  /** Dotted path to the value within the subform */
+  schemaPath: string;
+}
+
+/**
+ * Options for getting schema by multiple paths from a subform
+ */
+export interface GetSchemaByPathsSubformOptions {
+  /** Path to the subform */
+  subformPath: string;
+  /** Array of dotted paths to retrieve within the subform */
+  schemaPaths: string[];
+  /** Return format (Nested, Flat, or Array) */
+  format?: ReturnFormat;
+}
+
+/**
+ * Options for compiling and running logic
+ */
+export interface CompileAndRunLogicOptions {
+  /** Logic expression as string or object */
+  logicStr: string | object;
+  /** Optional data context */
+  data?: any;
+  /** Optional context data */
+  context?: any;
+}
+
+export class JSONEval {
+  constructor(options: JSONEvalOptions);
+  static fromCache(cacheKey: string, context?: any, data?: any): JSONEval;
+  init(): Promise<void>;
+  validate(options: ValidateOptions): Promise<ValidationResult>;
+  evaluate(options: EvaluateOptions): Promise<any>;
+  evaluateDependents(options: EvaluateDependentsOptions): Promise<DependentChange[]>;
+  compileAndRunLogic(options: CompileAndRunLogicOptions): Promise<any>;
+  compileLogic(logicStr: string | object): Promise<number>;
+  runLogic(logicId: number, data?: any, context?: any): Promise<any>;
+  getEvaluatedSchema(options?: GetEvaluatedSchemaOptions): Promise<any>;
+  getSchemaValue(): Promise<any>;
+  getEvaluatedSchemaWithoutParams(options?: GetEvaluatedSchemaOptions): Promise<any>;
+  getValueByPath(options: GetValueByPathOptions): Promise<any | null>;
+  getEvaluatedSchemaByPath(options: GetValueByPathOptions): Promise<any | null>;
+  getEvaluatedSchemaByPaths(options: GetValueByPathsOptions): Promise<any>;
+  getSchemaByPath(options: GetSchemaByPathOptions): Promise<any | null>;
+  getSchemaByPaths(options: GetSchemaByPathsOptions): Promise<any>;
+  reloadSchema(options: ReloadSchemaOptions): Promise<void>;
+  reloadSchemaMsgpack(schemaMsgpack: Uint8Array, context?: any, data?: any): Promise<void>;
+  reloadSchemaFromCache(cacheKey: string, context?: any, data?: any): Promise<void>;
+  cacheStats(): Promise<CacheStats>;
+  clearCache(): Promise<void>;
+  cacheLen(): Promise<number>;
+  enableCache(): Promise<void>;
+  disableCache(): Promise<void>;
+  isCacheEnabled(): boolean;
+  
+  // Subform methods
+  evaluateSubform(options: EvaluateSubformOptions): Promise<void>;
+  validateSubform(options: ValidateSubformOptions): Promise<ValidationResult>;
+  evaluateDependentsSubform(options: EvaluateDependentsSubformOptions): Promise<DependentChange[]>;
+  resolveLayoutSubform(options: ResolveLayoutSubformOptions): Promise<void>;
+  getEvaluatedSchemaSubform(options: GetEvaluatedSchemaSubformOptions): Promise<any>;
+  getSchemaValueSubform(options: GetSchemaValueSubformOptions): Promise<any>;
+  getEvaluatedSchemaWithoutParamsSubform(options: GetEvaluatedSchemaSubformOptions): Promise<any>;
+  getEvaluatedSchemaByPathSubform(options: GetEvaluatedSchemaByPathSubformOptions): Promise<any | null>;
+  getEvaluatedSchemaByPathsSubform(options: GetEvaluatedSchemaByPathsSubformOptions): Promise<any>;
+  getSchemaByPathSubform(options: GetSchemaByPathSubformOptions): Promise<any | null>;
+  getSchemaByPathsSubform(options: GetSchemaByPathsSubformOptions): Promise<any>;
+  getSubformPaths(): Promise<string[]>;
+  hasSubform(subformPath: string): Promise<boolean>;
+  
+  free(): void;
+}
+
+export function version(wasmModule?: any): Promise<string>;
+
+export default JSONEval;

package/index.js

@@ -0,0 +1,715 @@
+/**
+ * @json-eval-rs/webcore
+ * High-level JavaScript API for JSON Eval RS WASM bindings
+ * 
+ * This package provides a clean, ergonomic API that works with any WASM target:
+ */
+
+/**
+ * Get the library version from the WASM module
+ * @param {any} wasmModule - WASM module
+ * @returns {string} Version string
+ */
+export function getVersion(wasmModule) {
+  if (wasmModule && typeof wasmModule.getVersion === 'function') {
+    return wasmModule.getVersion();
+  }
+  return 'unknown';
+}
+
+/**
+ * JSONEval - High-level JavaScript API for JSON Eval RS
+ * 
+ * This is an internal abstraction layer. Use specific packages instead:
+ * - @json-eval-rs/bundler (for bundlers like Webpack, Vite, Next.js)
+ * - @json-eval-rs/vanilla (for direct browser usage)
+ * - @json-eval-rs/node (for Node.js/SSR)
+ * 
+ * @example
+ * ```js
+ * import { JSONEval } from '@json-eval-rs/webcore';
+ * 
+ * const evaluator = new JSONEval({
+ *   schema: { type: 'object', properties: { ... } }
+ * });
+ * 
+ * await evaluator.init();
+ * const result = await evaluator.validate({ data: { name: 'John' } });
+ * ```
+ */
+export class JSONEvalCore {
+  /**
+   * @param {any} wasmModule - WASM module (injected by wrapper package)
+   * @param {object} options
+   * @param {object|Uint8Array|string} options.schema - JSON schema, MessagePack bytes, or cache key
+   * @param {object} [options.context] - Optional context data
+   * @param {object} [options.data] - Optional initial data
+   * @param {boolean} [options.fromCache] - If true, schema is treated as a cache key
+   */
+  constructor(wasmModule, { schema, context, data, fromCache = false }) {
+    this._schema = schema;
+    this._wasmModule = wasmModule;
+    this._context = context;
+    this._data = data;
+    this._instance = null;
+    this._ready = false;
+    this._isMsgpackSchema = schema instanceof Uint8Array;
+    this._isFromCache = fromCache;
+  }
+
+  /**
+   * Initialize the WASM instance
+   * Call this before using other methods, or use the async methods which call it automatically
+   */
+  async init() {
+    if (this._ready) return;
+
+    // If WASM module not provided, throw error - user must provide it or install peer dependency
+    if (!this._wasmModule) {
+      throw new Error(
+        'No WASM module provided. Please either:\n' +
+        '1. Pass wasmModule in constructor: new JSONEval({ schema, wasmModule: await import("@json-eval-rs/bundler") })\n' +
+        '2. Or install a peer dependency: yarn install @json-eval-rs/bundler (or @json-eval-rs/vanilla or @json-eval-rs/node)'
+      );
+    }
+
+    try {
+      const { JSONEvalWasm } = this._wasmModule;
+      
+      // Create instance from cache, MessagePack, or JSON
+      if (this._isFromCache) {
+        this._instance = JSONEvalWasm.newFromCache(
+          this._schema, // cache key
+          this._context ? JSON.stringify(this._context) : null,
+          this._data ? JSON.stringify(this._data) : null
+        );
+      } else if (this._isMsgpackSchema) {
+        this._instance = JSONEvalWasm.newFromMsgpack(
+          this._schema,
+          this._context ? JSON.stringify(this._context) : null,
+          this._data ? JSON.stringify(this._data) : null
+        );
+      } else {
+        this._instance = new JSONEvalWasm(
+          JSON.stringify(this._schema),
+          this._context ? JSON.stringify(this._context) : null,
+          this._data ? JSON.stringify(this._data) : null
+        );
+      }
+      this._ready = true;
+    } catch (error) {
+      throw new Error(`Failed to create JSONEval instance: ${error.message || error}`);
+    }
+  }
+
+  /**
+   * Create a new JSONEval instance from a cached ParsedSchema
+   * Static factory method for convenience
+   * 
+   * @param {any} wasmModule - WASM module
+   * @param {string} cacheKey - Cache key to lookup in ParsedSchemaCache
+   * @param {object} [context] - Optional context data
+   * @param {object} [data] - Optional initial data
+   * @returns {JSONEvalCore} New instance
+   */
+  static fromCache(wasmModule, cacheKey, context, data) {
+    return new JSONEvalCore(wasmModule, {
+      schema: cacheKey,
+      context,
+      data,
+      fromCache: true
+    });
+  }
+
+  /**
+   * Validate data against schema (returns parsed JavaScript object)
+   * Uses validateJS for Worker-safe serialization
+   * @param {object} options
+   * @param {object} options.data - Data to validate
+   * @param {object} [options.context] - Optional context
+   * @returns {Promise<{has_error: boolean, errors: Array<{path: string, rule_type: string, message: string}>}>}
+   */
+  async validate({ data, context }) {
+    await this.init();
+    try {
+      // Use validateJS for proper serialization (Worker-safe)
+      return this._instance.validateJS(
+        JSON.stringify(data),
+        context ? JSON.stringify(context) : null
+      );
+    } catch (error) {
+      throw new Error(`Validation failed: ${error.message || error}`);
+    }
+  }
+
+  /**
+   * Evaluate schema with data (returns parsed JavaScript object)
+   * @param {object} options
+   * @param {object} options.data - Data to evaluate
+   * @param {object} [options.context] - Optional context
+   * @returns {Promise<any>}
+   */
+  async evaluate({ data, context }) {
+    await this.init();
+    try {
+      return this._instance.evaluateJS(
+        JSON.stringify(data),
+        context ? JSON.stringify(context) : null
+      );
+    } catch (error) {
+      throw new Error(`Evaluation failed: ${error.message || error}`);
+    }
+  }
+
+  /**
+   * Evaluate dependent fields (returns parsed JavaScript object, processes transitively)
+   * @param {object} options
+   * @param {string[]} options.changedPaths - Array of changed field paths (e.g., ["#/illustration/properties/field1", "field2"])
+   * @param {object} [options.data] - Optional updated data (null to use existing)
+   * @param {object} [options.context] - Optional context
+   * @param {boolean} [options.reEvaluate] - If true, performs full evaluation after processing dependents
+   * @returns {Promise<Array>} Array of dependent change objects
+   */
+  async evaluateDependents({ changedPaths, data, context, reEvaluate = false }) {
+    await this.init();
+    try {
+      return this._instance.evaluateDependentsJS(
+        JSON.stringify(changedPaths),
+        data ? JSON.stringify(data) : null,
+        context ? JSON.stringify(context) : null,
+        reEvaluate
+      );
+    } catch (error) {
+      throw new Error(`Dependent evaluation failed: ${error.message || error}`);
+    }
+  }
+
+  /**
+   * Get evaluated schema
+   * @param {object} [options]
+   * @param {boolean} [options.skipLayout=false] - Skip layout resolution
+   * @returns {Promise<any>}
+   */
+  async getEvaluatedSchema({ skipLayout = false } = {}) {
+    await this.init();
+    return this._instance.getEvaluatedSchemaJS(skipLayout);
+  }
+
+  /**
+   * Get evaluated schema as MessagePack binary data
+   * @param {object} [options]
+   * @param {boolean} [options.skipLayout=false] - Skip layout resolution
+   * @returns {Promise<Uint8Array>} MessagePack-encoded schema bytes
+   */
+  async getEvaluatedSchemaMsgpack({ skipLayout = false } = {}) {
+    await this.init();
+    return this._instance.getEvaluatedSchemaMsgpack(skipLayout);
+  }
+
+  /**
+   * Get schema values (evaluations ending with .value)
+   * @returns {Promise<object>}
+   */
+  async getSchemaValue() {
+    await this.init();
+    return this._instance.getSchemaValue();
+  }
+
+  /**
+   * Get evaluated schema without $params field
+   * @param {object} [options]
+   * @param {boolean} [options.skipLayout=false] - Skip layout resolution
+   * @returns {Promise<any>}
+   */
+  async getEvaluatedSchemaWithoutParams({ skipLayout = false } = {}) {
+    await this.init();
+    return this._instance.getEvaluatedSchemaWithoutParamsJS(skipLayout);
+  }
+
+  /**
+   * Get a value from the evaluated schema using dotted path notation
+   * @param {object} options
+   * @param {string} options.path - Dotted path to the value (e.g., "properties.field.value")
+   * @param {boolean} [options.skipLayout=false] - Skip layout resolution
+   * @returns {Promise<any|null>} Value at the path, or null if not found
+   */
+  async getEvaluatedSchemaByPath({ path, skipLayout = false }) {
+    await this.init();
+    return this._instance.getEvaluatedSchemaByPathJS(path, skipLayout);
+  }
+
+  /**
+   * Get values from the evaluated schema using multiple dotted path notations
+   * Returns data in the specified format (skips paths that are not found)
+   * @param {object} options
+   * @param {string[]} options.paths - Array of dotted paths to retrieve
+   * @param {boolean} [options.skipLayout=false] - Skip layout resolution
+   * @param {number} [options.format=0] - Return format (0=Nested, 1=Flat, 2=Array)
+   * @returns {Promise<any>} Data in specified format
+   */
+  async getEvaluatedSchemaByPaths({ paths, skipLayout = false, format = 0 }) {
+    await this.init();
+    return this._instance.getEvaluatedSchemaByPathsJS(JSON.stringify(paths), skipLayout, format);
+  }
+
+  /**
+   * Get a value from the schema using dotted path notation
+   * @param {object} options
+   * @param {string} options.path - Dotted path to the value (e.g., "properties.field.value")
+   * @returns {Promise<any|null>} Value at the path, or null if not found
+   */
+  async getSchemaByPath({ path }) {
+    await this.init();
+    return this._instance.getSchemaByPathJS(path);
+  }
+
+  /**
+   * Get values from the schema using multiple dotted path notations
+   * Returns data in the specified format (skips paths that are not found)
+   * @param {object} options
+   * @param {string[]} options.paths - Array of dotted paths to retrieve
+   * @param {number} [options.format=0] - Return format (0=Nested, 1=Flat, 2=Array)
+   * @returns {Promise<any>} Data in specified format
+   */
+  async getSchemaByPaths({ paths, format = 0 }) {
+    await this.init();
+    return this._instance.getSchemaByPathsJS(JSON.stringify(paths), format);
+  }
+
+  /**
+   * Reload schema with new data
+   * @param {object} options
+   * @param {object} options.schema - New JSON schema
+   * @param {object} [options.context] - Optional new context
+   * @param {object} [options.data] - Optional new data
+   * @returns {Promise<void>}
+   */
+  async reloadSchema({ schema, context, data }) {
+    if (!this._instance) {
+      throw new Error('Instance not initialized. Call init() first.');
+    }
+
+    try {
+      await this._instance.reloadSchema(
+        JSON.stringify(schema),
+        context ? JSON.stringify(context) : null,
+        data ? JSON.stringify(data) : null
+      );
+
+      // Update internal state
+      this._schema = schema;
+      this._context = context;
+      this._data = data;
+    } catch (error) {
+      throw new Error(`Failed to reload schema: ${error.message || error}`);
+    }
+  }
+
+  /**
+   * Reload schema from MessagePack bytes
+   * @param {Uint8Array} schemaMsgpack - MessagePack-encoded schema bytes
+   * @param {object} [context] - Optional new context
+   * @param {object} [data] - Optional new data
+   * @returns {Promise<void>}
+   */
+  async reloadSchemaMsgpack(schemaMsgpack, context, data) {
+    if (!this._instance) {
+      throw new Error('Instance not initialized. Call init() first.');
+    }
+
+    if (!(schemaMsgpack instanceof Uint8Array)) {
+      throw new Error('schemaMsgpack must be a Uint8Array');
+    }
+
+    try {
+      await this._instance.reloadSchemaMsgpack(
+        schemaMsgpack,
+        context ? JSON.stringify(context) : null,
+        data ? JSON.stringify(data) : null
+      );
+
+      // Update internal state
+      this._schema = schemaMsgpack;
+      this._context = context;
+      this._data = data;
+      this._isMsgpackSchema = true;
+    } catch (error) {
+      throw new Error(`Failed to reload schema from MessagePack: ${error.message || error}`);
+    }
+  }
+
+  /**
+   * Reload schema from ParsedSchemaCache using a cache key
+   * @param {string} cacheKey - Cache key to lookup in the global ParsedSchemaCache
+   * @param {object} [context] - Optional new context
+   * @param {object} [data] - Optional new data
+   * @returns {Promise<void>}
+   */
+  async reloadSchemaFromCache(cacheKey, context, data) {
+    if (!this._instance) {
+      throw new Error('Instance not initialized. Call init() first.');
+    }
+
+    if (typeof cacheKey !== 'string' || !cacheKey) {
+      throw new Error('cacheKey must be a non-empty string');
+    }
+
+    try {
+      await this._instance.reloadSchemaFromCache(
+        cacheKey,
+        context ? JSON.stringify(context) : null,
+        data ? JSON.stringify(data) : null
+      );
+
+      // Update internal state
+      this._context = context;
+      this._data = data;
+      // Note: schema is not updated as we don't have access to it from the cache key
+    } catch (error) {
+      throw new Error(`Failed to reload schema from cache: ${error.message || error}`);
+    }
+  }
+
+  /**
+   * Get cache statistics
+   * @returns {Promise<{hits: number, misses: number, entries: number}>}
+   */
+  async cacheStats() {
+    await this.init();
+    return this._instance.cacheStats();
+  }
+
+  /**
+   * Clear the evaluation cache
+   * @returns {Promise<void>}
+   */
+  async clearCache() {
+    await this.init();
+    this._instance.clearCache();
+  }
+
+  /**
+   * Get the number of cached entries
+   * @returns {Promise<number>}
+   */
+  async cacheLen() {
+    await this.init();
+    return this._instance.cacheLen();
+  }
+
+  /**
+   * Enable evaluation caching
+   * Useful for reusing JSONEval instances with different data
+   * @returns {Promise<void>}
+   */
+  async enableCache() {
+    await this.init();
+    this._instance.enableCache();
+  }
+
+  /**
+   * Disable evaluation caching
+   * Useful for web API usage where each request creates a new JSONEval instance
+   * Improves performance by skipping cache operations that have no benefit for single-use instances
+   * @returns {Promise<void>}
+   */
+  async disableCache() {
+    await this.init();
+    this._instance.disableCache();
+  }
+
+  /**
+   * Check if evaluation caching is enabled
+   * @returns {boolean}
+   */
+  isCacheEnabled() {
+    if (!this._instance) return true; // Default is enabled
+    return this._instance.isCacheEnabled();
+  }
+
+  /**
+   * Resolve layout with optional evaluation
+   * @param {object} [options]
+   * @param {boolean} [options.evaluate=false] - If true, runs evaluation before resolving layout
+   * @returns {Promise<void>}
+   */
+  async resolveLayout({ evaluate = false } = {}) {
+    await this.init();
+    return this._instance.resolveLayout(evaluate);
+  }
+
+  /**
+   * Compile and run JSON logic from a JSON logic string
+   * @param {object} options - Options for compile and run logic
+   * @param {string|object} options.logicStr - JSON logic expression as a string or object
+   * @param {object} [options.data] - Optional data to evaluate against (uses existing data if not provided)
+   * @param {object} [options.context] - Optional context to use (uses existing context if not provided)
+   * @returns {Promise<any>} Result of the evaluation
+   */
+  async compileAndRunLogic({ logicStr, data, context }) {
+    await this.init();
+    const logic = typeof logicStr === 'string' ? logicStr : JSON.stringify(logicStr);
+    const result = await this._instance.compileAndRunLogic(
+      logic,
+      data ? JSON.stringify(data) : null,
+      context ? JSON.stringify(context) : null
+    );
+    // Parse result if it's a string
+    return typeof result === 'string' ? JSON.parse(result) : result;
+  }
+
+  /**
+   * Compile JSON logic and return a global ID
+   * @param {string|object} logicStr - JSON logic expression as a string or object
+   * @returns {Promise<number>} Compiled logic ID
+   */
+  async compileLogic(logicStr) {
+    await this.init();
+    const logic = typeof logicStr === 'string' ? logicStr : JSON.stringify(logicStr);
+    return this._instance.compileLogic(logic);
+  }
+
+  /**
+   * Run pre-compiled logic by ID
+   * @param {number} logicId - Compiled logic ID from compileLogic
+   * @param {object} [data] - Optional data to evaluate against (uses existing data if not provided)
+   * @param {object} [context] - Optional context to use (uses existing context if not provided)
+   * @returns {Promise<any>} Result of the evaluation
+   */
+  async runLogic(logicId, data, context) {
+    await this.init();
+    const result = await this._instance.runLogic(
+      logicId,
+      data ? JSON.stringify(data) : null,
+      context ? JSON.stringify(context) : null
+    );
+    // Parse result if it's a string
+    return typeof result === 'string' ? JSON.parse(result) : result;
+  }
+
+  /**
+   * Validate data against schema rules with optional path filtering
+   * @param {object} options
+   * @param {object} options.data - Data to validate
+   * @param {object} [options.context] - Optional context
+   * @param {Array<string>} [options.paths] - Optional array of paths to validate (null for all)
+   * @returns {Promise<{has_error: boolean, errors: Array<{path: string, rule_type: string, message: string}>}>}
+   */
+  async validatePaths({ data, context, paths }) {
+    await this.init();
+    try {
+      // Use validatePathsJS for proper serialization (Worker-safe)
+      return this._instance.validatePathsJS(
+        JSON.stringify(data),
+        context ? JSON.stringify(context) : null,
+        paths || null
+      );
+    } catch (error) {
+      throw new Error(`Validation failed: ${error.message || error}`);
+    }
+  }
+
+  // ============================================================================
+  // Subform Methods
+  // ============================================================================
+
+  /**
+   * Evaluate a subform with data
+   * @param {object} options
+   * @param {string} options.subformPath - Path to the subform (e.g., "#/riders")
+   * @param {object} options.data - Data for the subform
+   * @param {object} [options.context] - Optional context
+   * @returns {Promise<void>}
+   */
+  async evaluateSubform({ subformPath, data, context }) {
+    await this.init();
+    return this._instance.evaluateSubform(
+      subformPath,
+      JSON.stringify(data),
+      context ? JSON.stringify(context) : null
+    );
+  }
+
+  /**
+   * Validate subform data against its schema rules
+   * @param {object} options
+   * @param {string} options.subformPath - Path to the subform
+   * @param {object} options.data - Data for the subform
+   * @param {object} [options.context] - Optional context
+   * @returns {Promise<{has_error: boolean, errors: Array}>}
+   */
+  async validateSubform({ subformPath, data, context }) {
+    await this.init();
+    return this._instance.validateSubform(
+      subformPath,
+      JSON.stringify(data),
+      context ? JSON.stringify(context) : null
+    );
+  }
+
+  /**
+   * Evaluate dependent fields in subform
+   * @param {object} options
+   * @param {string} options.subformPath - Path to the subform
+   * @param {string[]} options.changedPaths - Array of field paths that changed
+   * @param {object} [options.data] - Optional updated data
+   * @param {object} [options.context] - Optional context
+   * @param {boolean} [options.reEvaluate=false] - If true, performs full evaluation after processing dependents
+   * @returns {Promise<any>}
+   */
+  async evaluateDependentsSubform({ subformPath, changedPaths, data, context, reEvaluate = false }) {
+    await this.init();
+    
+    // For backward compatibility, accept single changedPath too
+    const paths = Array.isArray(changedPaths) ? changedPaths : [changedPaths];
+    
+    return this._instance.evaluateDependentsSubformJS(
+      subformPath,
+      paths[0], // WASM still expects single path (wraps internally)
+      data ? JSON.stringify(data) : null,
+      context ? JSON.stringify(context) : null
+    );
+  }
+
+  /**
+   * Resolve layout for subform
+   * @param {object} options
+   * @param {string} options.subformPath - Path to the subform
+   * @param {boolean} [options.evaluate=false] - If true, runs evaluation before resolving layout
+   * @returns {Promise<void>}
+   */
+  async resolveLayoutSubform({ subformPath, evaluate = false }) {
+    await this.init();
+    return this._instance.resolveLayoutSubform(subformPath, evaluate);
+  }
+
+  /**
+   * Get evaluated schema from subform
+   * @param {object} options
+   * @param {string} options.subformPath - Path to the subform
+   * @param {boolean} [options.resolveLayout=false] - Whether to resolve layout
+   * @returns {Promise<any>}
+   */
+  async getEvaluatedSchemaSubform({ subformPath, resolveLayout = false }) {
+    await this.init();
+    return this._instance.getEvaluatedSchemaSubformJS(subformPath, resolveLayout);
+  }
+
+  /**
+   * Get schema value from subform (all .value fields)
+   * @param {object} options
+   * @param {string} options.subformPath - Path to the subform
+   * @returns {Promise<any>}
+   */
+  async getSchemaValueSubform({ subformPath }) {
+    await this.init();
+    return this._instance.getSchemaValueSubform(subformPath);
+  }
+
+  /**
+   * Get evaluated schema without $params from subform
+   * @param {object} options
+   * @param {string} options.subformPath - Path to the subform
+   * @param {boolean} [options.resolveLayout=false] - Whether to resolve layout
+   * @returns {Promise<any>}
+   */
+  async getEvaluatedSchemaWithoutParamsSubform({ subformPath, resolveLayout = false }) {
+    await this.init();
+    return this._instance.getEvaluatedSchemaWithoutParamsSubformJS(subformPath, resolveLayout);
+  }
+
+  /**
+   * Get evaluated schema by specific path from subform
+   * @param {object} options
+   * @param {string} options.subformPath - Path to the subform
+   * @param {string} options.schemaPath - Path within the subform
+   * @param {boolean} [options.skipLayout=false] - Whether to skip layout resolution
+   * @returns {Promise<any|null>}
+   */
+  async getEvaluatedSchemaByPathSubform({ subformPath, schemaPath, skipLayout = false }) {
+    await this.init();
+    return this._instance.getEvaluatedSchemaByPathSubformJS(subformPath, schemaPath, skipLayout);
+  }
+
+  /**
+   * Get evaluated schema by multiple paths from subform
+   * Returns data in the specified format (skips paths that are not found)
+   * @param {object} options
+   * @param {string} options.subformPath - Path to the subform
+   * @param {string[]} options.schemaPaths - Array of paths within the subform
+   * @param {boolean} [options.skipLayout=false] - Whether to skip layout resolution
+   * @param {number} [options.format=0] - Return format (0=Nested, 1=Flat, 2=Array)
+   * @returns {Promise<any>}
+   */
+  async getEvaluatedSchemaByPathsSubform({ subformPath, schemaPaths, skipLayout = false, format = 0 }) {
+    await this.init();
+    return this._instance.getEvaluatedSchemaByPathsSubformJS(subformPath, JSON.stringify(schemaPaths), skipLayout, format);
+  }
+
+  /**
+   * Get list of available subform paths
+   * @returns {Promise<Array<string>>}
+   */
+  async getSubformPaths() {
+    await this.init();
+    return this._instance.getSubformPaths();
+  }
+
+  /**
+   * Get schema by specific path from subform
+   * @param {object} options
+   * @param {string} options.subformPath - Path to the subform
+   * @param {string} options.schemaPath - Path within the subform
+   * @returns {Promise<any|null>}
+   */
+  async getSchemaByPathSubform({ subformPath, schemaPath }) {
+    await this.init();
+    return this._instance.getSchemaByPathSubformJS(subformPath, schemaPath);
+  }
+
+  /**
+   * Get schema by multiple paths from subform
+   * Returns data in the specified format (skips paths that are not found)
+   * @param {object} options
+   * @param {string} options.subformPath - Path to the subform
+   * @param {string[]} options.schemaPaths - Array of paths within the subform
+   * @param {number} [options.format=0] - Return format (0=Nested, 1=Flat, 2=Array)
+   * @returns {Promise<any>}
+   */
+  async getSchemaByPathsSubform({ subformPath, schemaPaths, format = 0 }) {
+    await this.init();
+    return this._instance.getSchemaByPathsSubformJS(subformPath, JSON.stringify(schemaPaths), format);
+  }
+
+  /**
+   * Check if a subform exists at the given path
+   * @param {string} subformPath - Path to check
+   * @returns {Promise<boolean>}
+   */
+  async hasSubform(subformPath) {
+    await this.init();
+    return this._instance.hasSubform(subformPath);
+  }
+
+  /**
+   * Free WASM resources
+   */
+  free() {
+    if (this._instance) {
+      this._instance.free();
+      this._instance = null;
+      this._ready = false;
+    }
+  }
+}
+
+/**
+ * Get library version (internal - use from specific packages)
+ * @param {any} wasmModule - WASM module
+ * @returns {string}
+ */
+export function getVersion(wasmModule) {
+  return wasmModule.version();
+}
+
+export default JSONEvalCore;

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@json-eval-rs/webcore",
+  "version": "0.0.29",
+  "description": "JSON Eval RS core JavaScript wrapper (internal package - not published)",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "type": "module",
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "keywords": [
+    "json",
+    "json-logic",
+    "schema",
+    "validation",
+    "wasm"
+  ],
+  "author": "Muhamad Rizki",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/byrizki/json-eval-rs.git",
+    "directory": "bindings/web/packages/core"
+  },
+  "sideEffects": false
+}