@loydjs/runtime 1.0.0 → 1.1.0

package/README.md

@@ -1,171 +1,159 @@
 <div align="center">
 
-<h1>Loyd</h1>
+<h1>@loydjs/runtime</h1>
 
-
-**High-performance, tree-shakable schema validation for TypeScript.**
+<p><strong>Zero-copy execution engine for Loyd.</strong><br/>
+createExecutor · zeroCopy · abortEarly · deepFreeze · strict mode.</p>
 
 [![CI](https://github.com/b3nito404/loyd/actions/workflows/ci.yml/badge.svg)](https://github.com/b3nito404/loyd/actions/workflows/ci.yml)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
-[![Bundle](https://img.shields.io/badge/bundle-0.8kb-brightgreen.svg)](https://bundlephobia.com/package/@loydjs/schema)
+[![Bundle](https://img.shields.io/badge/bundle-~2kb-brightgreen.svg)](https://bundlephobia.com/package/@loydjs/runtime)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.4%2B-blue.svg)](https://www.typescriptlang.org)
-[![Version](https://img.shields.io/badge/version-1.0.0-blue.svg)](https://github.com/b3nito404/loyd/releases)
+[![npm downloads](https://img.shields.io/npm/dm/@loydjs/runtime?color=6366f1&label=downloads)](https://www.npmjs.com/package/@loydjs/runtime)
 
 </div>
 
 ---
 
-## Key features
+## Overview
+
+`@loydjs/runtime` provides a high-performance execution layer on top of `@loydjs/compiler`. Instead of calling `compile(schema)` and managing options manually, you create an `Executor` once with your desired options and reuse it across your entire application.
 
-- **0.8 kb minimal bundle** : functional `pipe()` composition enables full tree-shaking; import only what you use
-- **JIT compiler** : `compile(schema)` generates a pure JavaScript function via `new Function()`; subsequent calls are **2× faster** than `safeParse` on hot paths
-- **Structured i18n** : validators emit `{ code, path, meta }`, never locale strings; swap locales at runtime without touching your schemas
-- **Two-pass async pipeline** : sync rules execute first; async rules only if sync passes; multiple async rules run in parallel via `Promise.all`
-- **Field dependency graph** : `buildDag(schema, deps)` enables incremental revalidation; change one field -> revalidate only it and its dependents
-- **Native React integration** : `useForm`, `useField`, `useFieldArray` with zero external dependencies, backed by the DAG
+The key feature is **zero-copy mode** — on the success path, no result object is allocated. The input is returned directly, eliminating the `{ success, data, issues }` allocation that every other validation library performs on every call.
 
 ---
 
 ## Installation
 
 ```sh
-# Core  start here
-npm install @loydjs/schema @loydjs/core @loydjs/types
-
-# Optional packages
-npm install @loydjs/async          # two-pass async pipeline
-npm install @loydjs/compiler       # JIT compilation
-npm install @loydjs/error-engine   # structured i18n
-npm install @loydjs/react          # React hooks (requires @loydjs/graph)
-npm install @loydjs/graph          # field dependency DAG
-npm install @loydjs/zod-compat     # Zod migration utilities
-npm install @loydjs/openapi        # OpenAPI 3.1 / JSON Schema export
-npm install @loydjs/vite           # Vite / Rollup AOT plugin
+npm install @loydjs/runtime
 ```
-> **Requires** Node.js ≥ 20, TypeScript ≥ 5.4, and `"strict": true` in your `tsconfig.json`.
+
+> **Requires** `@loydjs/core` · `@loydjs/compiler` · Node.js ≥ 20 · TypeScript ≥ 5.4
 
 ---
 
-## Quick start
+## API
+
+### `createExecutor(options?)`
+
+Creates a reusable executor with fixed options. More efficient than passing options on every call — options are resolved once at creation time.
 
 ```ts
-import { object, pipe, string, number, email, minLength } from "@loydjs/schema";
-import { parse, safeParse } from "@loydjs/core";
-import type { Infer } from "@loydjs/types";
-
-// 1. Define your schema
-const UserSchema = object({
-  name:  pipe(string(), minLength(2)),
-  email: pipe(string(), email()),
-  age:   number().int().min(0),
-});
+import { createExecutor } from "@loydjs/runtime";
 
-// 2. Infer the TypeScript type - zero runtime cost
-type User = Infer<typeof UserSchema>;
-// -> { name: string; email: string; age: number }
+const executor = createExecutor({
+  zeroCopy:   true,     // skip { success, data, issues } allocation on success
+  abortEarly: true,     // stop validating after first error per object
+  freeze:     true,     // deep-freeze validated output
+  mode:       "strict", // "strip" | "strict" | "passthrough"
+});
 
-// 3a. parse()  throws LoydError on failure
-const user = parse(UserSchema, req.body);
+const result = executor.run(UserSchema, req.body);
 
-// 3b. safeParse()  never throws
-const result = safeParse(UserSchema, formData);
 if (result.success) {
-  console.log(result.data.name); // typed as User 
-} else {
-  result.issues.forEach(issue => {
-    console.log(issue.code);  // "ERR_STRING_TOO_SHORT"
-    console.log(issue.path);  // ["name"]
-    console.log(issue.meta);  // { min: 2, actual: 1 }
-  });
+  console.log(result.data); // typed as User, deep-frozen
 }
 ```
 
-### React forms
-
-```tsx
-import { useForm } from "@loydjs/react";
-
-function LoginForm() {
-  const { register, handleSubmit, state } = useForm({
-    schema: LoginSchema,
-    defaultValues: { email: "", password: "" },
-    mode: "onChange",
-  });
-
-  return (
-    <form onSubmit={handleSubmit(onValid, onInvalid)}>
-      <input {...register("email")} type="email" />
-      <input {...register("password")} type="password" />
-      <button type="submit" disabled={state.isSubmitting}>Sign in</button>
-    </form>
-  );
-}
-```
+### Pre-built executors
 
-### JIT compilation
+Three ready-to-use executors for the most common cases:
 
 ```ts
-import { compile } from "@loydjs/compiler";
+import {
+  defaultExecutor,    // mode: "strip", no freeze, no zeroCopy
+  zeroCopyExecutor,   // mode: "strip", zeroCopy: true
+  strictExecutor,     // mode: "strict", rejects unknown keys
+} from "@loydjs/runtime";
 
-const validate = compile(UserSchema);
+// Fastest possible — no result object allocated on success
+const result = zeroCopyExecutor.run(UserSchema, input);
 
-// 2× faster on hot paths - compiled once, cached per schema instance
-const result = validate(input); // LoydResult<User>
+// Reject unknown keys
+const result = strictExecutor.run(UserSchema, input);
 ```
 
-### i18n error formatting
+### `executor.runOrThrow(schema, input)`
+
+Throws a descriptive `Error` on failure instead of returning a result object.
 
 ```ts
-import { configureFormatter, fr } from "@loydjs/error-engine";
+const executor = createExecutor({ mode: "strict" });
+
+try {
+  const user = executor.runOrThrow(UserSchema, req.body);
+  // user is typed as User
+} catch (err) {
+  console.error(err.message);
+  // "Validation failed: ERR_STRING_INVALID_EMAIL at ["email"]"
+}
+```
+
+### `deepFreeze(value)`
 
-// Call once at app startup
-configureFormatter("fr", fr);
+Recursively freezes an object. Skips already-frozen objects for performance.
 
-// Issues are now formatted in French
-const result = safeParse(UserSchema, badInput);
-// result.issues[0].message -> "Minimum 2 caractères (reçu : 1)"
+```ts
+import { deepFreeze, isDeepFrozen } from "@loydjs/runtime";
+
+const frozen = deepFreeze({ name: "Alice", address: { city: "Paris" } });
+isDeepFrozen(frozen); // true
+frozen.name = "Bob";  // throws in strict mode
 ```
 
-### Migrate from Zod
+### `getModeConfig(mode)`
+
+Returns the configuration object for a given mode.
 
 ```ts
-import { fromZod, runCodemod } from "@loydjs/zod-compat";
+import { getModeConfig } from "@loydjs/runtime";
 
-// Convert a single schema
-const LoydUser = fromZod(zodUserSchema);
+getModeConfig("strict");
+// { stripUnknownKeys: false, errorOnUnknownKeys: true, passthroughUnknownKeys: false }
 
-// Or run the automated codemod across your entire codebase
-await runCodemod("./src", { write: true, verbose: true });
+getModeConfig("passthrough");
+// { stripUnknownKeys: false, errorOnUnknownKeys: false, passthroughUnknownKeys: true }
 ```
 
 ---
 
-## Packages
-
-| Package | Description | Size |
-|---|---|---|
-| `@loydjs/core` | `parse`, `safeParse`, `LoydError`, `BaseSchema` | 3.9 kb |
-| `@loydjs/schema` | All primitives, composites, modifiers, refinements | tree-shakeable |
-| `@loydjs/types` | `Infer<>`, `InferInput<>`, `InferOutput<>` | 0 kb runtime |
-| `@loydjs/async` | `parseAsync`, two-pass pipeline, `AbortSignal` | ~2 kb |
-| `@loydjs/compiler` | `compile()`, JIT codegen, cache management | ~4 kb |
-| `@loydjs/error-engine` | `createFormatter`, en/fr/es/ar locales | ~3 kb |
-| `@loydjs/graph` | `buildDag`, `validateIncremental`, dirty tracking | ~3 kb |
-| `@loydjs/react` | `useForm`, `useField`, `useFieldArray`, `FormProvider` | ~8 kb |
-| `@loydjs/zod-compat` | `fromZod`, `toZod`, `runCodemod` | ~5 kb |
-| `@loydjs/openapi` | `toOpenApi`, `toJsonSchema`, `toOpenApiComponents` | ~4 kb |
-| `@loydjs/vite` | `loydPlugin()` - Vite/Rollup AOT compilation | ~2 kb |
+## Executor options
+
+| Option | Type | Default | Description |
+|:---|:---|:---|:---|
+| `mode` | `"strip" \| "strict" \| "passthrough"` | `"strip"` | How unknown keys are handled |
+| `zeroCopy` | `boolean` | `false` | Skip result allocation on success |
+| `abortEarly` | `boolean` | `false` | Stop at first validation error |
+| `freeze` | `boolean` | `false` | Deep-freeze validated output |
 
 ---
 
-## Documentation
+## Mode comparison
+
+| Mode | Unknown keys | Use case |
+|:---|:---|:---|
+| `strip` | Removed silently | APIs, form validation |
+| `strict` | Error | Internal services, strict contracts |
+| `passthrough` | Kept as-is | Proxies, partial validation |
 
-For the full API reference, guides, and examples, visit the official documentation:
+---
+
+## Dependencies
+
+| Package | Role |
+|:---|:---|
+| `@loydjs/core` | `LoydSchema`, `LoydResult` types |
+| `@loydjs/compiler` | `compile()` for JIT validation |
+
+---
+
+## Documentation
 
-**[https://loyddev-psi.vercel.app](https://loyddev-psi.vercel.app)**
+**[loyddev-psi.vercel.app](https://loyddev-psi.vercel.app)**
 
 ---
 
 ## License
 
-MIT 
+MIT © [b3nito404](https://github.com/b3nito404)

package/dist/index.cjs

@@ -3,6 +3,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -15,5 +19,121 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 
 // src/index.ts
 var index_exports = {};
+__export(index_exports, {
+  createExecutor: () => createExecutor,
+  deepFreeze: () => deepFreeze,
+  defaultExecutor: () => defaultExecutor,
+  getModeConfig: () => getModeConfig,
+  isDeepFrozen: () => isDeepFrozen
+});
 module.exports = __toCommonJS(index_exports);
+
+// src/executor.ts
+var import_compiler = require("@loydjs/compiler");
+var _EMPTY_ISSUES = [];
+function makeSuccessResult(data) {
+  return { success: true, data, issues: _EMPTY_ISSUES };
+}
+function createExecutor(options = {}) {
+  const resolved = {
+    mode: options.mode ?? "strip",
+    freeze: options.freeze ?? false,
+    zeroCopy: options.zeroCopy ?? false,
+    abortEarly: options.abortEarly ?? false
+  };
+  const { freeze: doFreeze, zeroCopy } = resolved;
+  const maybeFreeze = doFreeze ? (v) => deepFreezeImpl(v) : (v) => v;
+  return {
+    options: resolved,
+    run(schema, input) {
+      const validator = (0, import_compiler.compile)(schema);
+      const result = validator(input);
+      if (!result.success) return result;
+      const data = maybeFreeze(result.data);
+      if (zeroCopy && data === result.data) {
+        return result;
+      }
+      return makeSuccessResult(data);
+    },
+    runOrThrow(schema, input) {
+      const validator = (0, import_compiler.compile)(schema);
+      const result = validator(input);
+      if (!result.success) {
+        const first = result.issues[0];
+        throw new Error(
+          first?.message ?? `Validation failed: ${first?.code ?? "ERR_UNKNOWN"} at ${JSON.stringify(first?.path ?? [])}`
+        );
+      }
+      return maybeFreeze(result.data);
+    }
+  };
+}
+var defaultExecutor = createExecutor();
+var zeroCopyExecutor = createExecutor({ zeroCopy: true });
+var strictExecutor = createExecutor({ mode: "strict" });
+function deepFreezeImpl(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Object.isFrozen(value)) return value;
+  Object.freeze(value);
+  for (const key of Object.keys(value)) {
+    const v = value[key];
+    if (v && typeof v === "object" && !Object.isFrozen(v)) {
+      deepFreezeImpl(v);
+    }
+  }
+  return value;
+}
+
+// src/mode.ts
+var CONFIGS = {
+  strip: {
+    stripUnknownKeys: true,
+    errorOnUnknownKeys: false,
+    passthroughUnknownKeys: false
+  },
+  strict: {
+    stripUnknownKeys: false,
+    errorOnUnknownKeys: true,
+    passthroughUnknownKeys: false
+  },
+  passthrough: {
+    stripUnknownKeys: false,
+    errorOnUnknownKeys: false,
+    passthroughUnknownKeys: true
+  }
+};
+function getModeConfig(mode) {
+  return CONFIGS[mode];
+}
+
+// src/freeze.ts
+function deepFreeze(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Object.isFrozen(value)) return value;
+  Object.freeze(value);
+  for (const key of Object.keys(value)) {
+    const v = value[key];
+    if (v && typeof v === "object" && !Object.isFrozen(v)) {
+      deepFreeze(v);
+    }
+  }
+  return value;
+}
+function isDeepFrozen(value) {
+  if (value === null || typeof value !== "object") return true;
+  if (!Object.isFrozen(value)) return false;
+  for (const key of Object.keys(value)) {
+    const v = value[key];
+    if (!isDeepFrozen(v)) return false;
+  }
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createExecutor,
+  deepFreeze,
+  defaultExecutor,
+  getModeConfig,
+  isDeepFrozen
+});
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export type { RuntimeMode, ExecutorOptions, Executor } from \"./executor.js\";\nexport { createExecutor, defaultExecutor } from \"./executor.js\";\n\nexport type { ModeConfig } from \"./mode.js\";\nexport { getModeConfig } from \"./mode.js\";\n\nexport { deepFreeze, isDeepFrozen } from \"./freeze.js\";\n"],"mappings":";;;;;;;;;;;;;;;;AAAA;AAAA;","names":[]}
+{"version":3,"sources":["../src/index.ts","../src/executor.ts","../src/mode.ts","../src/freeze.ts"],"sourcesContent":["export type { RuntimeMode, ExecutorOptions, Executor } from \"./executor.js\";\nexport { createExecutor, defaultExecutor } from \"./executor.js\";\n\nexport type { ModeConfig } from \"./mode.js\";\nexport { getModeConfig } from \"./mode.js\";\n\nexport { deepFreeze, isDeepFrozen } from \"./freeze.js\";\n","import { compile } from \"@loydjs/compiler\";\nimport type { LoydResult, LoydSchema } from \"@loydjs/core\";\n\nexport type RuntimeMode = \"strict\" | \"strip\" | \"passthrough\";\n\nexport interface ExecutorOptions {\n  mode?: RuntimeMode;\n  /**\n   * @default false\n   */\n  freeze?: boolean;\n  /**\n   * Skip creating a new result object on success  return input directly.\n   * @default false\n   */\n  zeroCopy?: boolean;\n  /**\n   * Stop validation after first error per object.\n   * @default false\n   */\n  abortEarly?: boolean;\n}\n\nexport interface Executor {\n  run<T>(schema: LoydSchema<T>, input: unknown): LoydResult<T>;\n  runOrThrow<T>(schema: LoydSchema<T>, input: unknown): T;\n  readonly options: Required<ExecutorOptions>;\n}\n\nconst _EMPTY_ISSUES: [] = [];\n\nfunction makeSuccessResult<T>(data: T): LoydResult<T> {\n  return { success: true, data, issues: _EMPTY_ISSUES };\n}\n\nexport function createExecutor(options: ExecutorOptions = {}): Executor {\n  const resolved: Required<ExecutorOptions> = {\n    mode: options.mode ?? \"strip\",\n    freeze: options.freeze ?? false,\n    zeroCopy: options.zeroCopy ?? false,\n    abortEarly: options.abortEarly ?? false,\n  };\n\n  const { freeze: doFreeze, zeroCopy } = resolved;\n\n  const maybeFreeze = doFreeze ? <T>(v: T): T => deepFreezeImpl(v) : <T>(v: T): T => v;\n\n  return {\n    options: resolved,\n\n    run<T>(schema: LoydSchema<T>, input: unknown): LoydResult<T> {\n      const validator = compile(schema);\n      const result = validator(input);\n\n      if (!result.success) return result;\n\n      const data = maybeFreeze(result.data);\n\n      if (zeroCopy && data === result.data) {\n        return result;\n      }\n\n      return makeSuccessResult(data);\n    },\n\n    runOrThrow<T>(schema: LoydSchema<T>, input: unknown): T {\n      const validator = compile(schema);\n      const result = validator(input);\n\n      if (!result.success) {\n        const first = result.issues[0];\n        throw new Error(\n          first?.message ??\n            `Validation failed: ${first?.code ?? \"ERR_UNKNOWN\"} at ${JSON.stringify(first?.path ?? [])}`,\n        );\n      }\n\n      return maybeFreeze(result.data);\n    },\n  };\n}\n\n/**strip mode*/\nexport const defaultExecutor: Executor = createExecutor();\n\nexport const zeroCopyExecutor: Executor = createExecutor({ zeroCopy: true });\n\nexport const strictExecutor: Executor = createExecutor({ mode: \"strict\" });\n\nfunction deepFreezeImpl<T>(value: T): T {\n  if (value === null || typeof value !== \"object\") return value;\n  if (Object.isFrozen(value)) return value;\n\n  Object.freeze(value);\n\n  for (const key of Object.keys(value as object)) {\n    const v = (value as Record<string, unknown>)[key];\n    if (v && typeof v === \"object\" && !Object.isFrozen(v)) {\n      deepFreezeImpl(v);\n    }\n  }\n\n  return value;\n}\n","import type { RuntimeMode } from \"./executor.js\";\n\nexport interface ModeConfig {\n  stripUnknownKeys: boolean;\n  errorOnUnknownKeys: boolean;\n  passthroughUnknownKeys: boolean;\n}\n\nconst CONFIGS: Record<RuntimeMode, ModeConfig> = {\n  strip: {\n    stripUnknownKeys: true,\n    errorOnUnknownKeys: false,\n    passthroughUnknownKeys: false,\n  },\n  strict: {\n    stripUnknownKeys: false,\n    errorOnUnknownKeys: true,\n    passthroughUnknownKeys: false,\n  },\n  passthrough: {\n    stripUnknownKeys: false,\n    errorOnUnknownKeys: false,\n    passthroughUnknownKeys: true,\n  },\n};\n\nexport function getModeConfig(mode: RuntimeMode): ModeConfig {\n  return CONFIGS[mode];\n}\n","export function deepFreeze<T>(value: T): Readonly<T> {\n  if (value === null || typeof value !== \"object\") return value as Readonly<T>;\n  if (Object.isFrozen(value)) return value as Readonly<T>;\n\n  Object.freeze(value);\n\n  for (const key of Object.keys(value as object)) {\n    const v = (value as Record<string, unknown>)[key];\n    if (v && typeof v === \"object\" && !Object.isFrozen(v)) {\n      deepFreeze(v);\n    }\n  }\n\n  return value as Readonly<T>;\n}\n\nexport function isDeepFrozen(value: unknown): boolean {\n  if (value === null || typeof value !== \"object\") return true;\n  if (!Object.isFrozen(value)) return false;\n\n  for (const key of Object.keys(value as object)) {\n    const v = (value as Record<string, unknown>)[key];\n    if (!isDeepFrozen(v)) return false;\n  }\n\n  return true;\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.cts

@@ -8,24 +8,23 @@ interface ExecutorOptions {
      */
     freeze?: boolean;
     /**
+     * Skip creating a new result object on success  return input directly.
      * @default false
      */
     zeroCopy?: boolean;
+    /**
+     * Stop validation after first error per object.
+     * @default false
+     */
+    abortEarly?: boolean;
 }
-/**
- * Creates an optimized executor with fixed options.
- * More efficient than going through the options on every call.
- * @example
- * const executor = createExecutor({ mode: "strict", freeze: true });
- * const result = executor.run(UserSchema, rawInput);
- */
 interface Executor {
     run<T>(schema: LoydSchema<T>, input: unknown): LoydResult<T>;
     runOrThrow<T>(schema: LoydSchema<T>, input: unknown): T;
     readonly options: Required<ExecutorOptions>;
 }
 declare function createExecutor(options?: ExecutorOptions): Executor;
-/** Default executor (mode: "strip", freeze: false, zeroCopy: false) */
+/**strip mode*/
 declare const defaultExecutor: Executor;
 
 interface ModeConfig {

package/dist/index.d.ts

@@ -8,24 +8,23 @@ interface ExecutorOptions {
      */
     freeze?: boolean;
     /**
+     * Skip creating a new result object on success  return input directly.
      * @default false
      */
     zeroCopy?: boolean;
+    /**
+     * Stop validation after first error per object.
+     * @default false
+     */
+    abortEarly?: boolean;
 }
-/**
- * Creates an optimized executor with fixed options.
- * More efficient than going through the options on every call.
- * @example
- * const executor = createExecutor({ mode: "strict", freeze: true });
- * const result = executor.run(UserSchema, rawInput);
- */
 interface Executor {
     run<T>(schema: LoydSchema<T>, input: unknown): LoydResult<T>;
     runOrThrow<T>(schema: LoydSchema<T>, input: unknown): T;
     readonly options: Required<ExecutorOptions>;
 }
 declare function createExecutor(options?: ExecutorOptions): Executor;
-/** Default executor (mode: "strip", freeze: false, zeroCopy: false) */
+/**strip mode*/
 declare const defaultExecutor: Executor;
 
 interface ModeConfig {

package/dist/index.js

@@ -1 +1,108 @@
+// src/executor.ts
+import { compile } from "@loydjs/compiler";
+var _EMPTY_ISSUES = [];
+function makeSuccessResult(data) {
+  return { success: true, data, issues: _EMPTY_ISSUES };
+}
+function createExecutor(options = {}) {
+  const resolved = {
+    mode: options.mode ?? "strip",
+    freeze: options.freeze ?? false,
+    zeroCopy: options.zeroCopy ?? false,
+    abortEarly: options.abortEarly ?? false
+  };
+  const { freeze: doFreeze, zeroCopy } = resolved;
+  const maybeFreeze = doFreeze ? (v) => deepFreezeImpl(v) : (v) => v;
+  return {
+    options: resolved,
+    run(schema, input) {
+      const validator = compile(schema);
+      const result = validator(input);
+      if (!result.success) return result;
+      const data = maybeFreeze(result.data);
+      if (zeroCopy && data === result.data) {
+        return result;
+      }
+      return makeSuccessResult(data);
+    },
+    runOrThrow(schema, input) {
+      const validator = compile(schema);
+      const result = validator(input);
+      if (!result.success) {
+        const first = result.issues[0];
+        throw new Error(
+          first?.message ?? `Validation failed: ${first?.code ?? "ERR_UNKNOWN"} at ${JSON.stringify(first?.path ?? [])}`
+        );
+      }
+      return maybeFreeze(result.data);
+    }
+  };
+}
+var defaultExecutor = createExecutor();
+var zeroCopyExecutor = createExecutor({ zeroCopy: true });
+var strictExecutor = createExecutor({ mode: "strict" });
+function deepFreezeImpl(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Object.isFrozen(value)) return value;
+  Object.freeze(value);
+  for (const key of Object.keys(value)) {
+    const v = value[key];
+    if (v && typeof v === "object" && !Object.isFrozen(v)) {
+      deepFreezeImpl(v);
+    }
+  }
+  return value;
+}
+
+// src/mode.ts
+var CONFIGS = {
+  strip: {
+    stripUnknownKeys: true,
+    errorOnUnknownKeys: false,
+    passthroughUnknownKeys: false
+  },
+  strict: {
+    stripUnknownKeys: false,
+    errorOnUnknownKeys: true,
+    passthroughUnknownKeys: false
+  },
+  passthrough: {
+    stripUnknownKeys: false,
+    errorOnUnknownKeys: false,
+    passthroughUnknownKeys: true
+  }
+};
+function getModeConfig(mode) {
+  return CONFIGS[mode];
+}
+
+// src/freeze.ts
+function deepFreeze(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Object.isFrozen(value)) return value;
+  Object.freeze(value);
+  for (const key of Object.keys(value)) {
+    const v = value[key];
+    if (v && typeof v === "object" && !Object.isFrozen(v)) {
+      deepFreeze(v);
+    }
+  }
+  return value;
+}
+function isDeepFrozen(value) {
+  if (value === null || typeof value !== "object") return true;
+  if (!Object.isFrozen(value)) return false;
+  for (const key of Object.keys(value)) {
+    const v = value[key];
+    if (!isDeepFrozen(v)) return false;
+  }
+  return true;
+}
+export {
+  createExecutor,
+  deepFreeze,
+  defaultExecutor,
+  getModeConfig,
+  isDeepFrozen
+};
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"sources":["../src/executor.ts","../src/mode.ts","../src/freeze.ts"],"sourcesContent":["import { compile } from \"@loydjs/compiler\";\nimport type { LoydResult, LoydSchema } from \"@loydjs/core\";\n\nexport type RuntimeMode = \"strict\" | \"strip\" | \"passthrough\";\n\nexport interface ExecutorOptions {\n  mode?: RuntimeMode;\n  /**\n   * @default false\n   */\n  freeze?: boolean;\n  /**\n   * Skip creating a new result object on success  return input directly.\n   * @default false\n   */\n  zeroCopy?: boolean;\n  /**\n   * Stop validation after first error per object.\n   * @default false\n   */\n  abortEarly?: boolean;\n}\n\nexport interface Executor {\n  run<T>(schema: LoydSchema<T>, input: unknown): LoydResult<T>;\n  runOrThrow<T>(schema: LoydSchema<T>, input: unknown): T;\n  readonly options: Required<ExecutorOptions>;\n}\n\nconst _EMPTY_ISSUES: [] = [];\n\nfunction makeSuccessResult<T>(data: T): LoydResult<T> {\n  return { success: true, data, issues: _EMPTY_ISSUES };\n}\n\nexport function createExecutor(options: ExecutorOptions = {}): Executor {\n  const resolved: Required<ExecutorOptions> = {\n    mode: options.mode ?? \"strip\",\n    freeze: options.freeze ?? false,\n    zeroCopy: options.zeroCopy ?? false,\n    abortEarly: options.abortEarly ?? false,\n  };\n\n  const { freeze: doFreeze, zeroCopy } = resolved;\n\n  const maybeFreeze = doFreeze ? <T>(v: T): T => deepFreezeImpl(v) : <T>(v: T): T => v;\n\n  return {\n    options: resolved,\n\n    run<T>(schema: LoydSchema<T>, input: unknown): LoydResult<T> {\n      const validator = compile(schema);\n      const result = validator(input);\n\n      if (!result.success) return result;\n\n      const data = maybeFreeze(result.data);\n\n      if (zeroCopy && data === result.data) {\n        return result;\n      }\n\n      return makeSuccessResult(data);\n    },\n\n    runOrThrow<T>(schema: LoydSchema<T>, input: unknown): T {\n      const validator = compile(schema);\n      const result = validator(input);\n\n      if (!result.success) {\n        const first = result.issues[0];\n        throw new Error(\n          first?.message ??\n            `Validation failed: ${first?.code ?? \"ERR_UNKNOWN\"} at ${JSON.stringify(first?.path ?? [])}`,\n        );\n      }\n\n      return maybeFreeze(result.data);\n    },\n  };\n}\n\n/**strip mode*/\nexport const defaultExecutor: Executor = createExecutor();\n\nexport const zeroCopyExecutor: Executor = createExecutor({ zeroCopy: true });\n\nexport const strictExecutor: Executor = createExecutor({ mode: \"strict\" });\n\nfunction deepFreezeImpl<T>(value: T): T {\n  if (value === null || typeof value !== \"object\") return value;\n  if (Object.isFrozen(value)) return value;\n\n  Object.freeze(value);\n\n  for (const key of Object.keys(value as object)) {\n    const v = (value as Record<string, unknown>)[key];\n    if (v && typeof v === \"object\" && !Object.isFrozen(v)) {\n      deepFreezeImpl(v);\n    }\n  }\n\n  return value;\n}\n","import type { RuntimeMode } from \"./executor.js\";\n\nexport interface ModeConfig {\n  stripUnknownKeys: boolean;\n  errorOnUnknownKeys: boolean;\n  passthroughUnknownKeys: boolean;\n}\n\nconst CONFIGS: Record<RuntimeMode, ModeConfig> = {\n  strip: {\n    stripUnknownKeys: true,\n    errorOnUnknownKeys: false,\n    passthroughUnknownKeys: false,\n  },\n  strict: {\n    stripUnknownKeys: false,\n    errorOnUnknownKeys: true,\n    passthroughUnknownKeys: false,\n  },\n  passthrough: {\n    stripUnknownKeys: false,\n    errorOnUnknownKeys: false,\n    passthroughUnknownKeys: true,\n  },\n};\n\nexport function getModeConfig(mode: RuntimeMode): ModeConfig {\n  return CONFIGS[mode];\n}\n","export function deepFreeze<T>(value: T): Readonly<T> {\n  if (value === null || typeof value !== \"object\") return value as Readonly<T>;\n  if (Object.isFrozen(value)) return value as Readonly<T>;\n\n  Object.freeze(value);\n\n  for (const key of Object.keys(value as object)) {\n    const v = (value as Record<string, unknown>)[key];\n    if (v && typeof v === \"object\" && !Object.isFrozen(v)) {\n      deepFreeze(v);\n    }\n  }\n\n  return value as Readonly<T>;\n}\n\nexport function isDeepFrozen(value: unknown): boolean {\n  if (value === null || typeof value !== \"object\") return true;\n  if (!Object.isFrozen(value)) return false;\n\n  for (const key of Object.keys(value as object)) {\n    const v = (value as Record<string, unknown>)[key];\n    if (!isDeepFrozen(v)) return false;\n  }\n\n  return true;\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loydjs/runtime",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Loyd runtime — zero-copy execution engine",
   "keywords": [
     "loyd",
@@ -32,8 +32,8 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@loydjs/core": "1.0.0",
-    "@loydjs/compiler": "1.0.0"
+    "@loydjs/core": "1.1.0",
+    "@loydjs/compiler": "1.1.0"
   },
   "devDependencies": {
     "typescript": "^5.7.2",

package/src/executor.ts

@@ -1,3 +1,4 @@
+import { compile } from "@loydjs/compiler";
 import type { LoydResult, LoydSchema } from "@loydjs/core";
 
 export type RuntimeMode = "strict" | "strip" | "passthrough";
@@ -9,25 +10,95 @@ export interface ExecutorOptions {
    */
   freeze?: boolean;
   /**
+   * Skip creating a new result object on success  return input directly.
    * @default false
    */
   zeroCopy?: boolean;
+  /**
+   * Stop validation after first error per object.
+   * @default false
+   */
+  abortEarly?: boolean;
 }
 
-/**
- * Creates an optimized executor with fixed options.
- * More efficient than going through the options on every call.
- * @example
- * const executor = createExecutor({ mode: "strict", freeze: true });
- * const result = executor.run(UserSchema, rawInput);
- */
 export interface Executor {
   run<T>(schema: LoydSchema<T>, input: unknown): LoydResult<T>;
   runOrThrow<T>(schema: LoydSchema<T>, input: unknown): T;
   readonly options: Required<ExecutorOptions>;
 }
 
-export declare function createExecutor(options?: ExecutorOptions): Executor;
+const _EMPTY_ISSUES: [] = [];
+
+function makeSuccessResult<T>(data: T): LoydResult<T> {
+  return { success: true, data, issues: _EMPTY_ISSUES };
+}
+
+export function createExecutor(options: ExecutorOptions = {}): Executor {
+  const resolved: Required<ExecutorOptions> = {
+    mode: options.mode ?? "strip",
+    freeze: options.freeze ?? false,
+    zeroCopy: options.zeroCopy ?? false,
+    abortEarly: options.abortEarly ?? false,
+  };
+
+  const { freeze: doFreeze, zeroCopy } = resolved;
+
+  const maybeFreeze = doFreeze ? <T>(v: T): T => deepFreezeImpl(v) : <T>(v: T): T => v;
+
+  return {
+    options: resolved,
+
+    run<T>(schema: LoydSchema<T>, input: unknown): LoydResult<T> {
+      const validator = compile(schema);
+      const result = validator(input);
+
+      if (!result.success) return result;
+
+      const data = maybeFreeze(result.data);
+
+      if (zeroCopy && data === result.data) {
+        return result;
+      }
 
-/** Default executor (mode: "strip", freeze: false, zeroCopy: false) */
-export declare const defaultExecutor: Executor;
+      return makeSuccessResult(data);
+    },
+
+    runOrThrow<T>(schema: LoydSchema<T>, input: unknown): T {
+      const validator = compile(schema);
+      const result = validator(input);
+
+      if (!result.success) {
+        const first = result.issues[0];
+        throw new Error(
+          first?.message ??
+            `Validation failed: ${first?.code ?? "ERR_UNKNOWN"} at ${JSON.stringify(first?.path ?? [])}`,
+        );
+      }
+
+      return maybeFreeze(result.data);
+    },
+  };
+}
+
+/**strip mode*/
+export const defaultExecutor: Executor = createExecutor();
+
+export const zeroCopyExecutor: Executor = createExecutor({ zeroCopy: true });
+
+export const strictExecutor: Executor = createExecutor({ mode: "strict" });
+
+function deepFreezeImpl<T>(value: T): T {
+  if (value === null || typeof value !== "object") return value;
+  if (Object.isFrozen(value)) return value;
+
+  Object.freeze(value);
+
+  for (const key of Object.keys(value as object)) {
+    const v = (value as Record<string, unknown>)[key];
+    if (v && typeof v === "object" && !Object.isFrozen(v)) {
+      deepFreezeImpl(v);
+    }
+  }
+
+  return value;
+}

package/src/freeze.ts

@@ -1,2 +1,27 @@
-export declare function deepFreeze<T>(value: T): Readonly<T>;
-export declare function isDeepFrozen(value: unknown): boolean;
+export function deepFreeze<T>(value: T): Readonly<T> {
+  if (value === null || typeof value !== "object") return value as Readonly<T>;
+  if (Object.isFrozen(value)) return value as Readonly<T>;
+
+  Object.freeze(value);
+
+  for (const key of Object.keys(value as object)) {
+    const v = (value as Record<string, unknown>)[key];
+    if (v && typeof v === "object" && !Object.isFrozen(v)) {
+      deepFreeze(v);
+    }
+  }
+
+  return value as Readonly<T>;
+}
+
+export function isDeepFrozen(value: unknown): boolean {
+  if (value === null || typeof value !== "object") return true;
+  if (!Object.isFrozen(value)) return false;
+
+  for (const key of Object.keys(value as object)) {
+    const v = (value as Record<string, unknown>)[key];
+    if (!isDeepFrozen(v)) return false;
+  }
+
+  return true;
+}

package/src/mode.ts

@@ -1,8 +1,29 @@
 import type { RuntimeMode } from "./executor.js";
+
 export interface ModeConfig {
   stripUnknownKeys: boolean;
   errorOnUnknownKeys: boolean;
   passthroughUnknownKeys: boolean;
 }
 
-export declare function getModeConfig(mode: RuntimeMode): ModeConfig;
+const CONFIGS: Record<RuntimeMode, ModeConfig> = {
+  strip: {
+    stripUnknownKeys: true,
+    errorOnUnknownKeys: false,
+    passthroughUnknownKeys: false,
+  },
+  strict: {
+    stripUnknownKeys: false,
+    errorOnUnknownKeys: true,
+    passthroughUnknownKeys: false,
+  },
+  passthrough: {
+    stripUnknownKeys: false,
+    errorOnUnknownKeys: false,
+    passthroughUnknownKeys: true,
+  },
+};
+
+export function getModeConfig(mode: RuntimeMode): ModeConfig {
+  return CONFIGS[mode];
+}