@crustjs/validate 0.0.1

package/README.md

@@ -0,0 +1,178 @@
+# @crustjs/validate
+
+> Experimental: API may change between minor versions.
+
+Validation support for the [Crust](https://crustjs.com) CLI framework.
+
+## Entry points
+
+| Entry | Import | Purpose |
+| --- | --- | --- |
+| Shared contracts | `@crustjs/validate` | Provider-agnostic types (`ValidatedContext`, `ValidationIssue`) |
+| Effect provider | `@crustjs/validate/effect` | Schema-first command API (`defineEffectCommand`, `arg`, `flag`) |
+| Zod provider | `@crustjs/validate/zod` | Schema-first command API (`defineZodCommand`, `arg`, `flag`) |
+
+## Install
+
+```sh
+bun add @crustjs/validate
+
+# choose one or both providers
+bun add zod
+bun add effect
+```
+
+## Effect schema-first mode (`defineEffectCommand`)
+
+Define schemas once and let Crust `args`/`flags` definitions be generated automatically.
+
+```ts
+import { runMain } from "@crustjs/core";
+import {
+	arg,
+	defineEffectCommand,
+	flag,
+} from "@crustjs/validate/effect";
+import * as Schema from "effect/Schema";
+
+const serve = defineEffectCommand({
+	meta: { name: "serve", description: "Start dev server" },
+	args: [
+		arg("port", Schema.Number.annotations({ description: "Port to listen on" })),
+		arg("host", Schema.UndefinedOr(
+			Schema.String.annotations({ description: "Host to bind" }),
+		)),
+	],
+	flags: {
+		verbose: flag(
+			Schema.Boolean.annotations({ description: "Enable verbose logging" }),
+			{ alias: "v" },
+		),
+		format: flag(
+			Schema.Literal("json", "text").annotations({ description: "Output format" }),
+			{ alias: "f" },
+		),
+	},
+	run({ args, flags, input }) {
+		// args: { port: number; host: string | undefined }
+		// flags: { verbose: boolean; format: "json" | "text" }
+		console.log(args.port, args.host, flags.verbose, flags.format);
+		console.log(input.args, input.flags); // original parser output
+	},
+});
+
+runMain(serve);
+```
+
+### Effect schema support
+
+- Primitive schemas: `Schema.String`, `Schema.Number`, `Schema.Boolean`
+- Enums/literals: `Schema.Enums(...)`, `Schema.Literal(...)`
+- Arrays: `Schema.Array(...)` and array-like tuple rest schemas
+- Wrappers: refinement/transformation/suspend wrappers are unwrapped for parser-shape analysis
+- Descriptions: `schema.annotations({ description: "..." })` — auto-extracted through wrappers
+
+For optional args/flags, use schemas whose encoded input allows `undefined` (for example `Schema.UndefinedOr(Schema.String)`).
+
+## Zod schema-first mode (`defineZodCommand`)
+
+Define schemas once and let Crust `args`/`flags` definitions be generated automatically.
+
+```ts
+import { runMain } from "@crustjs/core";
+import { arg, defineZodCommand, flag } from "@crustjs/validate/zod";
+import { z } from "zod";
+
+const serve = defineZodCommand({
+	meta: { name: "serve", description: "Start dev server" },
+	args: [
+		arg("port", z.number().int().min(1).max(65535).describe("Port to listen on")),
+		arg("host", z.string().default("localhost").describe("Host to bind")),
+	],
+	flags: {
+		verbose: flag(
+			z.boolean().default(false).describe("Enable verbose logging"),
+			{ alias: "v" },
+		),
+		format: flag(
+			z.enum(["json", "text"]).default("text").describe("Output format"),
+			{ alias: "f" },
+		),
+	},
+	run({ args, flags, input }) {
+		// args: { port: number; host: string }
+		// flags: { verbose: boolean; format: "json" | "text" }
+		console.log(args.port, args.host, flags.verbose, flags.format);
+		console.log(input.args, input.flags); // original parser output
+	},
+});
+
+runMain(serve);
+```
+
+### Zod schema support
+
+- Primitive schemas: `z.string()`, `z.number()`, `z.boolean()`
+- Enums/literals: `z.enum(...)`, `z.literal(...)`
+- Arrays: `z.array(...)` for flags with `multiple: true`
+- Wrappers: `.optional()`, `.default()`, `.nullable()`, `.transform()`, `.pipe()`
+- Descriptions: `.describe("...")` — auto-extracted through wrappers
+
+### Positional args
+
+- Use ordered `arg(name, schema, options?)` entries.
+- Optional/default schemas become optional CLI args (`[name]`).
+- Variadic args use `{ variadic: true }` and must be last.
+
+```ts
+args: [
+	arg("mode", z.string()),
+	arg("files", z.string(), { variadic: true }),
+];
+```
+
+### Flags
+
+- Pass plain Zod schemas or `flag(schema, options?)` wrappers.
+- Use `flag(..., { alias })` for short aliases.
+- Use `.describe("...")` on the schema for help text.
+
+```ts
+flags: {
+	debug: z.boolean().default(false).describe("Enable debug mode"),
+	outDir: flag(z.string().default("dist").describe("Output directory"), { alias: "o" }),
+};
+```
+
+### Help plugin compatibility
+
+Generated definitions are compatible with `helpPlugin`.
+
+```ts
+import { runMain } from "@crustjs/core";
+import { helpPlugin } from "@crustjs/plugins";
+
+runMain(serve, { plugins: [helpPlugin()] });
+```
+
+### Lifecycle hooks
+
+`defineZodCommand` supports `preRun` and `postRun` passthrough hooks.
+
+- Both hooks receive the core `CommandContext` (raw parser output).
+- Schema validation/transforms run inside `run`, so validated values are only
+  available in the schema-first `run` handler.
+
+## Validation errors
+
+Failures throw `CrustError("VALIDATION")`.
+
+- Message: bullet-list output with dot paths (for example `args.port`, `flags.verbose`).
+- Structured issues: available on both `error.details.issues` and `error.cause`.
+
+## v1 constraints
+
+- Args and flags only (no env/config validation).
+- Effect mode currently supports context-free schemas only (`R = never`).
+- Zod mode requires Zod 4+.
+- No automatic schema inheritance across subcommands.

package/dist/effect/index.d.ts

@@ -0,0 +1,148 @@
+import { AnyCommand as AnyCommand2, ValidateFlagAliases, ValidateVariadicArgs } from "@crustjs/core";
+import { CommandContext, CommandDef } from "@crustjs/core";
+import * as schema from "effect/Schema";
+import { AnyCommand } from "@crustjs/core";
+/**
+* Extended command context passed to validated handlers.
+*
+* After validation, `args` and `flags` contain the transformed schema output.
+* The original pre-validation parsed values are preserved in `input` for
+* advanced or debug use.
+*/
+interface ValidatedContext<
+	ArgsOut,
+	FlagsOut
+> {
+	/** Transformed positional arguments after schema validation */
+	args: ArgsOut;
+	/** Transformed flags after schema validation */
+	flags: FlagsOut;
+	/** Raw arguments that appeared after the `--` separator */
+	rawArgs: string[];
+	/** The resolved command being executed */
+	command: AnyCommand;
+	/** Original pre-validation parsed values from the Crust parser */
+	input: {
+		/** Original parsed args before schema transformation */
+		args: Record<string, unknown>;
+		/** Original parsed flags before schema transformation */
+		flags: Record<string, unknown>;
+	};
+}
+/**
+* An Effect schema used by the Effect entrypoint.
+*
+* v1 intentionally supports context-free schemas only (`R = never`).
+* Schemas must also be **synchronous** — async combinators such as
+* `Schema.filterEffect` or async `Schema.transformOrFail` will cause
+* `Effect.runSync` to throw at runtime.
+*/
+type EffectSchemaLike = schema.Schema.AnyNoContext;
+/** Infer output type from an Effect schema. */
+type InferSchemaOutput<S> = S extends schema.Schema<infer A, infer _I, infer _R> ? A : never;
+/** Optional metadata for a positional argument declared with `arg()`. */
+interface ArgOptions {
+	/** Collect remaining positionals into this arg as an array. */
+	readonly variadic?: true;
+}
+/** A single positional argument spec produced by `arg()`. */
+interface ArgSpec<
+	Name extends string = string,
+	SchemaType extends EffectSchemaLike = EffectSchemaLike,
+	Variadic extends true | undefined = true | undefined
+> {
+	readonly kind: "arg";
+	readonly name: Name;
+	readonly schema: SchemaType;
+	readonly variadic: Variadic;
+}
+/** Ordered positional argument specs. */
+type ArgSpecs = readonly ArgSpec[];
+/** Output type for one ArgSpec in the validated handler context. */
+type InferArgValue<S extends ArgSpec> = S["variadic"] extends true ? InferSchemaOutput<S["schema"]>[] : InferSchemaOutput<S["schema"]>;
+/** Flattens an intersection of objects for readable inferred types. */
+type Simplify<T> = { [K in keyof T] : T[K] };
+/** Recursively maps ordered ArgSpec entries to a named output object type. */
+type InferArgsFromTuple<A extends readonly ArgSpec[]> = A extends readonly [infer Head extends ArgSpec, ...infer Tail extends readonly ArgSpec[]] ? { [K in Head["name"]] : InferArgValue<Head> } & InferArgsFromTuple<Tail> : {};
+/** Infer validated args object type from ordered ArgSpec entries. */
+type InferArgsFromSpecs<A extends ArgSpecs> = Simplify<InferArgsFromTuple<A>>;
+/** Optional metadata for a flag declared with `flag()`. */
+interface FlagOptions {
+	/** Short alias or array of aliases (e.g. `"v"` or `["v", "V"]`). */
+	readonly alias?: string | readonly string[];
+}
+/** A named flag schema wrapper produced by `flag()`. */
+interface FlagSpec<
+	SchemaType extends EffectSchemaLike = EffectSchemaLike,
+	Alias extends string | readonly string[] | undefined = string | readonly string[] | undefined
+> {
+	readonly kind: "flag";
+	readonly schema: SchemaType;
+	readonly alias: Alias;
+}
+/** Allowed value shape for `flags` in `defineEffectCommand()`. */
+type FlagShape = Record<string, EffectSchemaLike | FlagSpec>;
+/** Extract the schema from a flag shape value (plain schema or `flag()` wrapper). */
+type ExtractFlagSchema<V> = V extends FlagSpec<infer S> ? S : V extends EffectSchemaLike ? V : never;
+/** Infer validated flags object type from the flags shape. */
+type InferFlagsFromShape<F extends FlagShape> = { [K in keyof F] : InferSchemaOutput<ExtractFlagSchema<F[K]>> };
+/** Handler type for `defineEffectCommand()` with validated/transformed context. */
+type EffectCommandRunHandler<
+	ArgsOut,
+	FlagsOut
+> = (context: ValidatedContext<ArgsOut, FlagsOut>) => void | Promise<void>;
+/** Infer args output type from command config args. */
+type InferArgsFromConfig<A> = A extends ArgSpecs ? InferArgsFromSpecs<A> : Record<string, never>;
+/** Infer flags output type from command config flags. */
+type InferFlagsFromConfig<F> = F extends FlagShape ? InferFlagsFromShape<F> : Record<string, never>;
+type EffectOverriddenKeys = "args" | "flags" | "run" | "preRun" | "postRun";
+/** Config for `defineEffectCommand()` using `arg()` + `flag()` schema-first DSL. */
+interface EffectCommandDef<
+	A extends ArgSpecs | undefined = undefined,
+	F extends FlagShape | undefined = undefined
+> extends Omit<CommandDef, EffectOverriddenKeys> {
+	/** Ordered positional args as `arg()` specs. */
+	readonly args?: A;
+	/** Named flags as plain schemas or `flag()` wrappers. */
+	readonly flags?: F;
+	/** Optional setup hook before schema validation runs. */
+	readonly preRun?: (context: CommandContext) => void | Promise<void>;
+	/** Main handler with validated/transformed args and flags. */
+	readonly run?: EffectCommandRunHandler<InferArgsFromConfig<A>, InferFlagsFromConfig<F>>;
+	/** Optional teardown hook after command execution. */
+	readonly postRun?: (context: CommandContext) => void | Promise<void>;
+}
+/**
+* Define a Crust command where Effect schemas are the source of truth.
+*
+* Only context-free (`R = never`), synchronous schemas are supported.
+* Async combinators like `Schema.filterEffect` or async `Schema.transformOrFail`
+* will throw at runtime.
+*/
+declare function defineEffectCommand<
+	const A extends readonly ArgSpec[] | undefined,
+	const F extends FlagShape | undefined
+>(config: EffectCommandDef<A, F> & {
+	args?: A extends readonly object[] ? ValidateVariadicArgs<A> : A;
+	flags?: F extends Record<string, unknown> ? ValidateFlagAliases<F> : F;
+}): AnyCommand2;
+/**
+* Define a named positional argument schema for `defineEffectCommand()`.
+*/
+declare function arg<
+	Name extends string,
+	SchemaType extends EffectSchemaLike,
+	const Variadic extends true | undefined = undefined
+>(name: Name, schema: SchemaType, options?: ArgOptions & {
+	variadic?: Variadic;
+}): ArgSpec<Name, SchemaType, Variadic>;
+/**
+* Define a flag schema for `defineEffectCommand()` with optional alias metadata.
+*/
+declare function flag<
+	SchemaType extends EffectSchemaLike,
+	const Alias extends string | readonly string[] | undefined = undefined
+>(schema: SchemaType, options?: FlagOptions & {
+	alias?: Alias;
+}): FlagSpec<SchemaType, Alias>;
+export { flag, defineEffectCommand, arg, InferSchemaOutput, InferFlagsFromShape, InferFlagsFromConfig, InferArgsFromSpecs, InferArgsFromConfig, FlagSpec, FlagShape, FlagOptions, EffectSchemaLike, EffectCommandRunHandler, EffectCommandDef, ArgSpecs, ArgSpec, ArgOptions };

package/dist/effect/index.js

@@ -0,0 +1,274 @@
+// @bun
+import {
+  buildArgDefinitions,
+  buildFlagDefinitions,
+  buildRunHandler,
+  normalizeIssues
+} from "../shared/chunk-zfhm7pmv.js";
+
+// src/effect/command.ts
+import { defineCommand } from "@crustjs/core";
+import { either, runSync } from "effect/Effect";
+import * as Either from "effect/Either";
+import * as ParseResult from "effect/ParseResult";
+import { decodeUnknown } from "effect/Schema";
+
+// src/effect/definitions.ts
+import { CrustError as CrustError2 } from "@crustjs/core";
+import { encodedSchema } from "effect/Schema";
+
+// src/effect/schema.ts
+import { CrustError } from "@crustjs/core";
+import { isSome } from "effect/Option";
+import { isSchema } from "effect/Schema";
+import { getDescriptionAnnotation } from "effect/SchemaAST";
+function arg(name, schema, options) {
+  if (!name.trim()) {
+    throw new CrustError("DEFINITION", "arg(): name is required and must be a non-empty string");
+  }
+  if (!isSchema(schema)) {
+    throw new CrustError("DEFINITION", `arg("${name}"): schema must be an Effect schema`);
+  }
+  return {
+    kind: "arg",
+    name,
+    schema,
+    variadic: options?.variadic
+  };
+}
+function flag(schema, options) {
+  if (!isSchema(schema)) {
+    throw new CrustError("DEFINITION", "flag(): schema must be an Effect schema");
+  }
+  return {
+    kind: "flag",
+    schema,
+    alias: options?.alias
+  };
+}
+function resolveDescription(schema) {
+  return resolveDescriptionFromAst(schema.ast);
+}
+function resolveDescriptionFromAst(ast) {
+  const seen = new Set;
+  let current = ast;
+  for (;; ) {
+    if (seen.has(current)) {
+      return;
+    }
+    seen.add(current);
+    const annotated = getDescriptionAnnotation(current);
+    if (isSome(annotated) && typeof annotated.value === "string") {
+      return annotated.value;
+    }
+    if (current._tag === "Transformation") {
+      current = current.from;
+      continue;
+    }
+    if (current._tag === "Refinement") {
+      current = current.from;
+      continue;
+    }
+    if (current._tag === "Suspend") {
+      current = current.f();
+      continue;
+    }
+    if (current._tag === "Union") {
+      for (const member of current.types) {
+        if (member._tag === "UndefinedKeyword") {
+          continue;
+        }
+        const desc = resolveDescriptionFromAst(member);
+        if (desc !== undefined) {
+          return desc;
+        }
+      }
+      return;
+    }
+    return;
+  }
+}
+
+// src/effect/definitions.ts
+function unwrapInputAst(ast) {
+  let current = ast;
+  const seen = new Set;
+  for (;; ) {
+    if (seen.has(current)) {
+      return current;
+    }
+    seen.add(current);
+    if (current._tag === "Refinement") {
+      current = current.from;
+      continue;
+    }
+    if (current._tag === "Transformation") {
+      current = current.from;
+      continue;
+    }
+    if (current._tag === "Suspend") {
+      current = current.f();
+      continue;
+    }
+    return current;
+  }
+}
+function resolveEnumInputType(enums) {
+  let kind;
+  for (const [, value] of enums) {
+    if (typeof value !== "string" && typeof value !== "number") {
+      return;
+    }
+    const current = typeof value === "string" ? "string" : "number";
+    if (kind === undefined) {
+      kind = current;
+      continue;
+    }
+    if (kind !== current) {
+      return;
+    }
+  }
+  return kind;
+}
+function resolvePrimitiveInputType(ast) {
+  const unwrapped = unwrapInputAst(ast);
+  if (unwrapped._tag === "StringKeyword" || unwrapped._tag === "TemplateLiteral") {
+    return "string";
+  }
+  if (unwrapped._tag === "NumberKeyword") {
+    return "number";
+  }
+  if (unwrapped._tag === "BooleanKeyword") {
+    return "boolean";
+  }
+  if (unwrapped._tag === "Literal") {
+    if (typeof unwrapped.literal === "string")
+      return "string";
+    if (typeof unwrapped.literal === "number")
+      return "number";
+    if (typeof unwrapped.literal === "boolean")
+      return "boolean";
+    return;
+  }
+  if (unwrapped._tag === "Enums") {
+    return resolveEnumInputType(unwrapped.enums);
+  }
+  if (unwrapped._tag === "Union") {
+    let kind;
+    for (const member of unwrapped.types) {
+      const resolved = resolvePrimitiveInputType(member);
+      if (resolved === undefined) {
+        if (unwrapInputAst(member)._tag === "UndefinedKeyword") {
+          continue;
+        }
+        return;
+      }
+      if (kind === undefined) {
+        kind = resolved;
+        continue;
+      }
+      if (kind !== resolved) {
+        return;
+      }
+    }
+    return kind;
+  }
+  return;
+}
+function resolveTupleArrayShape(ast, label) {
+  if (ast._tag !== "TupleType") {
+    return;
+  }
+  if (ast.elements.length > 0) {
+    throw new CrustError2("DEFINITION", `${label}: tuple schemas with fixed elements are not supported for CLI parsing. Use Schema.Array(T) for repeatable arguments.`);
+  }
+  if (ast.rest.length !== 1) {
+    throw new CrustError2("DEFINITION", `${label}: tuple schemas are not supported for CLI parsing. Use scalar schemas or array schemas with a single element type.`);
+  }
+  const rest = ast.rest[0];
+  if (!rest) {
+    throw new CrustError2("DEFINITION", `${label}: unable to inspect array element schema`);
+  }
+  const primitive = resolvePrimitiveInputType(rest.type);
+  if (!primitive) {
+    throw new CrustError2("DEFINITION", `${label}: array element type must be string, number, or boolean`);
+  }
+  return { type: primitive, multiple: true };
+}
+function resolveInputShape(schema, label) {
+  const ast = unwrapInputAst(encodedSchema(schema).ast);
+  const tupleShape = resolveTupleArrayShape(ast, label);
+  if (tupleShape) {
+    return tupleShape;
+  }
+  const primitive = resolvePrimitiveInputType(ast);
+  if (primitive) {
+    return { type: primitive, multiple: false };
+  }
+  throw new CrustError2("DEFINITION", `${label}: unsupported schema type for CLI parsing. Use string, number, boolean, enum/literal, or array of these.`);
+}
+function acceptsUndefined(ast) {
+  const unwrapped = unwrapInputAst(ast);
+  if (unwrapped._tag === "UndefinedKeyword") {
+    return true;
+  }
+  if (unwrapped._tag === "Union") {
+    return unwrapped.types.some((member) => acceptsUndefined(member));
+  }
+  return false;
+}
+function isOptionalInputSchema(schema) {
+  return acceptsUndefined(encodedSchema(schema).ast);
+}
+var effectAdapter = {
+  resolveInputShape,
+  isOptionalInputSchema,
+  resolveDescription,
+  commandLabel: "defineEffectCommand",
+  arrayHint: "Schema.Array(...)"
+};
+function argsToDefinitions(args) {
+  return buildArgDefinitions(args, effectAdapter);
+}
+function flagsToDefinitions(flags) {
+  return buildFlagDefinitions(flags, effectAdapter);
+}
+
+// src/effect/command.ts
+function validateValue(schema, value, prefix) {
+  const result = runSync(either(decodeUnknown(schema)(value)));
+  if (Either.isRight(result)) {
+    return { ok: true, value: result.right };
+  }
+  const flattened = ParseResult.ArrayFormatter.formatErrorSync(result.left);
+  const prefixed = flattened.map((issue) => ({
+    message: issue.message,
+    path: [...prefix, ...issue.path]
+  }));
+  return { ok: false, issues: normalizeIssues(prefixed) };
+}
+function defineEffectCommand(config) {
+  const {
+    args: effectArgs,
+    flags: effectFlags,
+    run: userRun,
+    ...passthrough
+  } = config;
+  const argSpecs = effectArgs ?? [];
+  const generatedArgs = argsToDefinitions(argSpecs);
+  const generatedFlags = flagsToDefinitions(effectFlags);
+  const command = defineCommand({
+    ...passthrough,
+    ...generatedArgs.length > 0 && { args: generatedArgs },
+    ...Object.keys(generatedFlags).length > 0 && { flags: generatedFlags },
+    ...userRun && {
+      run: buildRunHandler(argSpecs, effectFlags, userRun, validateValue)
+    }
+  });
+  return command;
+}
+export {
+  flag,
+  defineEffectCommand,
+  arg
+};

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+import { AnyCommand } from "@crustjs/core";
+/**
+* A normalized validation issue used internally across both entrypoints.
+*
+* Provider issues may use path arrays. This type normalizes them to a
+* flat string-based dot-path for consistent rendering
+* and programmatic consumption.
+*/
+interface ValidationIssue {
+	/** Human-readable error message for this issue. */
+	readonly message: string;
+	/** Dot-path string describing the location of the issue (e.g. `"flags.verbose"`, `"args[0]"`). Empty string for root-level issues. */
+	readonly path: string;
+}
+/**
+* Extended command context passed to validated handlers.
+*
+* After validation, `args` and `flags` contain the transformed schema output.
+* The original pre-validation parsed values are preserved in `input` for
+* advanced or debug use.
+*/
+interface ValidatedContext<
+	ArgsOut,
+	FlagsOut
+> {
+	/** Transformed positional arguments after schema validation */
+	args: ArgsOut;
+	/** Transformed flags after schema validation */
+	flags: FlagsOut;
+	/** Raw arguments that appeared after the `--` separator */
+	rawArgs: string[];
+	/** The resolved command being executed */
+	command: AnyCommand;
+	/** Original pre-validation parsed values from the Crust parser */
+	input: {
+		/** Original parsed args before schema transformation */
+		args: Record<string, unknown>;
+		/** Original parsed flags before schema transformation */
+		flags: Record<string, unknown>;
+	};
+}
+export { ValidationIssue, ValidatedContext };

package/dist/index.js

@@ -0,0 +1 @@
+// @bun

package/dist/shared/chunk-zfhm7pmv.js

@@ -0,0 +1,196 @@
+// @bun
+// src/validation.ts
+import { CrustError } from "@crustjs/core";
+function formatPath(path) {
+  let result = "";
+  for (const segment of path) {
+    if (typeof segment === "number") {
+      result += `[${String(segment)}]`;
+    } else {
+      const str = String(segment);
+      if (result.length > 0) {
+        result += `.${str}`;
+      } else {
+        result = str;
+      }
+    }
+  }
+  return result;
+}
+function normalizeIssue(issue) {
+  return {
+    message: issue.message,
+    path: issue.path ? formatPath(issue.path) : ""
+  };
+}
+function normalizeIssues(issues) {
+  return issues.map(normalizeIssue);
+}
+function renderIssueLine(issue) {
+  if (issue.path) {
+    return `  - ${issue.path}: ${issue.message}`;
+  }
+  return `  - ${issue.message}`;
+}
+function renderBulletList(prefix, issues) {
+  if (issues.length === 0)
+    return prefix;
+  const lines = issues.map(renderIssueLine);
+  return `${prefix}
+${lines.join(`
+`)}`;
+}
+function throwValidationError(issues, prefix = "Validation failed") {
+  const message = renderBulletList(prefix, issues);
+  throw new CrustError("VALIDATION", message, { issues }).withCause(issues);
+}
+
+// src/flagSpec.ts
+function isFlagSpec(value) {
+  return typeof value === "object" && value !== null && "kind" in value && value.kind === "flag";
+}
+function getFlagSchema(value) {
+  return isFlagSpec(value) ? value.schema : value;
+}
+
+// src/runner.ts
+async function validateArgs(argSpecs, context, issues, validateValue) {
+  const output = {};
+  for (const spec of argSpecs) {
+    const input = context.args[spec.name];
+    if (spec.variadic) {
+      const items = Array.isArray(input) ? input : input === undefined ? [] : [input];
+      const transformed = [];
+      for (let i = 0;i < items.length; i++) {
+        const value = items[i];
+        const validated2 = await validateValue(spec.schema, value, [
+          "args",
+          spec.name,
+          i
+        ]);
+        if (!validated2.ok) {
+          issues.push(...validated2.issues);
+          continue;
+        }
+        transformed.push(validated2.value);
+      }
+      output[spec.name] = transformed;
+      continue;
+    }
+    const validated = await validateValue(spec.schema, input, [
+      "args",
+      spec.name
+    ]);
+    if (!validated.ok) {
+      issues.push(...validated.issues);
+      continue;
+    }
+    output[spec.name] = validated.value;
+  }
+  return output;
+}
+async function validateFlags(flags, context, issues, validateValue) {
+  if (!flags) {
+    return {};
+  }
+  const output = {};
+  for (const [name, rawValue] of Object.entries(flags)) {
+    const schema = getFlagSchema(rawValue);
+    const input = context.flags[name];
+    const validated = await validateValue(schema, input, ["flags", name]);
+    if (!validated.ok) {
+      issues.push(...validated.issues);
+      continue;
+    }
+    output[name] = validated.value;
+  }
+  return output;
+}
+function buildRunHandler(argSpecs, flags, userRun, validateValue) {
+  return async (context) => {
+    const issues = [];
+    const validatedArgs = await validateArgs(argSpecs, context, issues, validateValue);
+    const validatedFlags = await validateFlags(flags, context, issues, validateValue);
+    if (issues.length > 0) {
+      throwValidationError(issues);
+    }
+    const validatedContext = {
+      args: validatedArgs,
+      flags: validatedFlags,
+      rawArgs: context.rawArgs,
+      command: context.command,
+      input: {
+        args: context.args,
+        flags: context.flags
+      }
+    };
+    return userRun(validatedContext);
+  };
+}
+
+// src/definitionBuilders.ts
+import { CrustError as CrustError2 } from "@crustjs/core";
+function buildArgDefinitions(args, adapter) {
+  const seen = new Set;
+  for (let i = 0;i < args.length; i++) {
+    const spec = args[i];
+    if (!spec)
+      continue;
+    if (seen.has(spec.name)) {
+      throw new CrustError2("DEFINITION", `${adapter.commandLabel}: duplicate arg name "${spec.name}"`);
+    }
+    seen.add(spec.name);
+    if (spec.variadic && i !== args.length - 1) {
+      throw new CrustError2("DEFINITION", `${adapter.commandLabel}: only the last arg can be variadic (arg "${spec.name}")`);
+    }
+  }
+  return args.map((spec) => {
+    const shape = adapter.resolveInputShape(spec.schema, `arg "${spec.name}"`);
+    if (spec.variadic && shape.multiple) {
+      throw new CrustError2("DEFINITION", `arg "${spec.name}": variadic args must use a scalar schema; do not wrap the schema in ${adapter.arrayHint}`);
+    }
+    if (!spec.variadic && shape.multiple) {
+      throw new CrustError2("DEFINITION", `arg "${spec.name}": array schema requires { variadic: true }`);
+    }
+    const description = adapter.resolveDescription(spec.schema);
+    const required = !adapter.isOptionalInputSchema(spec.schema);
+    const def = {
+      name: spec.name,
+      type: shape.type,
+      ...description !== undefined && { description },
+      ...spec.variadic && { variadic: true },
+      ...required && { required: true }
+    };
+    return def;
+  });
+}
+function getFlagMetadata(value) {
+  if (isFlagSpec(value)) {
+    return { schema: value.schema, alias: value.alias };
+  }
+  return { schema: value };
+}
+function buildFlagDefinitions(flags, adapter) {
+  if (!flags) {
+    return {};
+  }
+  const result = {};
+  for (const [name, value] of Object.entries(flags)) {
+    const metadata = getFlagMetadata(value);
+    const { schema } = metadata;
+    const shape = adapter.resolveInputShape(schema, `flag "--${name}"`);
+    const required = !adapter.isOptionalInputSchema(schema);
+    const description = adapter.resolveDescription(schema);
+    const alias = metadata.alias === undefined ? undefined : typeof metadata.alias === "string" ? metadata.alias : [...metadata.alias];
+    result[name] = {
+      type: shape.type,
+      ...shape.multiple && { multiple: true },
+      ...alias !== undefined && { alias },
+      ...description !== undefined && { description },
+      ...required && { required: true }
+    };
+  }
+  return result;
+}
+
+export { normalizeIssues, buildRunHandler, buildArgDefinitions, buildFlagDefinitions };

package/dist/zod/index.d.ts

@@ -0,0 +1,212 @@
+import { AnyCommand as AnyCommand2, ValidateFlagAliases, ValidateVariadicArgs } from "@crustjs/core";
+import { CommandContext, CommandDef } from "@crustjs/core";
+import * as z from "zod/v4/core";
+import { AnyCommand } from "@crustjs/core";
+/**
+* Extended command context passed to validated handlers.
+*
+* After validation, `args` and `flags` contain the transformed schema output.
+* The original pre-validation parsed values are preserved in `input` for
+* advanced or debug use.
+*/
+interface ValidatedContext<
+	ArgsOut,
+	FlagsOut
+> {
+	/** Transformed positional arguments after schema validation */
+	args: ArgsOut;
+	/** Transformed flags after schema validation */
+	flags: FlagsOut;
+	/** Raw arguments that appeared after the `--` separator */
+	rawArgs: string[];
+	/** The resolved command being executed */
+	command: AnyCommand;
+	/** Original pre-validation parsed values from the Crust parser */
+	input: {
+		/** Original parsed args before schema transformation */
+		args: Record<string, unknown>;
+		/** Original parsed flags before schema transformation */
+		flags: Record<string, unknown>;
+	};
+}
+/** A Zod schema used by the Zod entrypoint. */
+type ZodSchemaLike<
+	Input = unknown,
+	Output = Input
+> = z.$ZodType<Output, Input>;
+/** Infer output type from a Zod schema. */
+type InferSchemaOutput<S> = S extends z.$ZodType ? z.output<S> : never;
+/** Optional metadata for a positional argument declared with `arg()`. */
+interface ArgOptions {
+	/** Collect remaining positionals into this arg as an array. */
+	readonly variadic?: true;
+}
+/**
+* A single positional argument spec produced by `arg()`.
+*
+* The `Variadic` generic parameter preserves the literal `true` from
+* `arg()` calls so `ValidateVariadicArgs` can distinguish variadic args
+* from non-variadic ones at compile time.
+*
+* - `ArgSpec<N, S, true>` — variadic arg (only valid in last position)
+* - `ArgSpec<N, S, undefined>` — normal positional arg
+* - `ArgSpec<N, S>` (default) — type-erased form used in constraints
+*/
+interface ArgSpec<
+	Name extends string = string,
+	Schema extends ZodSchemaLike = ZodSchemaLike,
+	Variadic extends true | undefined = true | undefined
+> {
+	readonly kind: "arg";
+	readonly name: Name;
+	readonly schema: Schema;
+	readonly variadic: Variadic;
+}
+/** Ordered positional argument specs. */
+type ArgSpecs = readonly ArgSpec[];
+/** Output type for one ArgSpec in the validated handler context. */
+type InferArgValue<S extends ArgSpec> = S["variadic"] extends true ? InferSchemaOutput<S["schema"]>[] : InferSchemaOutput<S["schema"]>;
+/** Flattens an intersection of objects for readable inferred types. */
+type Simplify<T> = { [K in keyof T] : T[K] };
+/** Recursively maps ordered ArgSpec entries to a named output object type. */
+type InferArgsFromTuple<A extends readonly ArgSpec[]> = A extends readonly [infer Head extends ArgSpec, ...infer Tail extends readonly ArgSpec[]] ? { [K in Head["name"]] : InferArgValue<Head> } & InferArgsFromTuple<Tail> : {};
+/** Infer validated args object type from ordered ArgSpec entries. */
+type InferArgsFromSpecs<A extends ArgSpecs> = Simplify<InferArgsFromTuple<A>>;
+/** Optional metadata for a flag declared with `flag()`. */
+interface FlagOptions {
+	/** Short alias or array of aliases (e.g. `"v"` or `["v", "V"]`). */
+	readonly alias?: string | readonly string[];
+}
+/**
+* A named flag schema wrapper produced by `flag()`.
+*
+* The `Alias` generic parameter preserves alias literals (e.g. `"v"` or
+* `readonly ["v", "V"]`) from `flag()` calls so `ValidateFlagAliases` can
+* detect collisions at compile time.
+*
+* - `FlagSpec<S, "v">` — flag with alias `"v"` (collision-detectable)
+* - `FlagSpec<S, undefined>` — flag without an alias
+* - `FlagSpec<S>` (default) — type-erased form used in constraints
+*/
+interface FlagSpec<
+	Schema extends ZodSchemaLike = ZodSchemaLike,
+	Alias extends string | readonly string[] | undefined = string | readonly string[] | undefined
+> {
+	readonly kind: "flag";
+	readonly schema: Schema;
+	readonly alias: Alias;
+}
+/** Allowed value shape for `flags` in `defineZodCommand()`. */
+type FlagShape = Record<string, ZodSchemaLike | FlagSpec>;
+/** Extract the schema from a flag shape value (plain schema or `flag()` wrapper). */
+type ExtractFlagSchema<V> = V extends FlagSpec<infer S> ? S : V extends ZodSchemaLike ? V : never;
+/** Infer validated flags object type from the flags shape. */
+type InferFlagsFromShape<F extends FlagShape> = { [K in keyof F] : InferSchemaOutput<ExtractFlagSchema<F[K]>> };
+/** Handler type for `defineZodCommand()` with validated/transformed context. */
+type ZodCommandRunHandler<
+	ArgsOut,
+	FlagsOut
+> = (context: ValidatedContext<ArgsOut, FlagsOut>) => void | Promise<void>;
+/** Infer args output type from command config args. */
+type InferArgsFromConfig<A> = A extends ArgSpecs ? InferArgsFromSpecs<A> : Record<string, never>;
+/** Infer flags output type from command config flags. */
+type InferFlagsFromConfig<F> = F extends FlagShape ? InferFlagsFromShape<F> : Record<string, never>;
+/**
+* Keys from `CommandDef` that `ZodCommandDef` redefines with different types.
+*
+* - `args` / `flags`: Zod schema-based definitions replace core's `ArgsDef`/`FlagsDef`
+* - `run`: receives `ValidatedContext` instead of raw `CommandContext`
+* - `preRun` / `postRun`: use raw `CommandContext` (no `NoInfer` wrapper)
+*
+* All remaining `CommandDef` keys (e.g. `meta`, `subCommands`) are inherited
+* automatically via `Omit`. If a new passthrough field is added to `CommandDef`,
+* it propagates here without changes. The compile-time key exhaustiveness
+* assertion in `command.test.ts` will fail, forcing a review.
+*/
+type ZodOverriddenKeys = "args" | "flags" | "run" | "preRun" | "postRun";
+/**
+* Config for `defineZodCommand()` using `arg()` + `flag()` schema-first DSL.
+*
+* Extends `CommandDef` (minus overridden keys) so passthrough fields like
+* `meta` and `subCommands` stay in sync automatically. If a new field is
+* added to `CommandDef`, the key exhaustiveness assertion in
+* `command.test.ts` fails at compile time, forcing a review.
+*/
+interface ZodCommandDef<
+	A extends ArgSpecs | undefined = undefined,
+	F extends FlagShape | undefined = undefined
+> extends Omit<CommandDef, ZodOverriddenKeys> {
+	/** Ordered positional args as `arg()` specs. */
+	readonly args?: A;
+	/** Named flags as plain schemas or `flag()` wrappers. */
+	readonly flags?: F;
+	/**
+	* Optional setup hook before schema validation runs.
+	*
+	* Receives raw parser output (`CommandContext`), not schema-transformed values.
+	*/
+	readonly preRun?: (context: CommandContext) => void | Promise<void>;
+	/** Main handler with validated/transformed args and flags. */
+	readonly run?: ZodCommandRunHandler<InferArgsFromConfig<A>, InferFlagsFromConfig<F>>;
+	/**
+	* Optional teardown hook after command execution.
+	*
+	* Receives raw parser output (`CommandContext`), not schema-transformed values.
+	*/
+	readonly postRun?: (context: CommandContext) => void | Promise<void>;
+}
+/**
+* Define a Crust command where schemas are the source of truth.
+*
+* Positional args are declared with `arg(name, schema)` in an ordered array,
+* flags are declared as plain schemas or `flag(schema, meta)` wrappers.
+*
+* The factory generates Crust parser/help definitions and runs schema
+* validation after parsing but before user handler execution.
+*
+* Compile-time validation (via intersection branding) catches:
+* - Variadic args that aren't in the last position
+* - Flag alias collisions (alias→name or alias→alias)
+*/
+declare function defineZodCommand<
+	const A extends readonly ArgSpec[] | undefined,
+	const F extends FlagShape | undefined
+>(config: ZodCommandDef<A, F> & {
+	args?: A extends readonly object[] ? ValidateVariadicArgs<A> : A;
+	flags?: F extends Record<string, unknown> ? ValidateFlagAliases<F> : F;
+}): AnyCommand2;
+/**
+* Define a named positional argument schema for `defineZodCommand()`.
+*
+* The `const Variadic` parameter preserves `{ variadic: true }` as a
+* literal in the return type, enabling compile-time variadic position
+* validation in `defineZodCommand()`.
+*
+* @param name - Positional arg name used in parser output and help text
+* @param schema - Zod schema
+* @param options - Optional CLI metadata (description, variadic)
+*/
+declare function arg<
+	Name extends string,
+	Schema extends ZodSchemaLike,
+	const Variadic extends true | undefined = undefined
+>(name: Name, schema: Schema, options?: ArgOptions & {
+	variadic?: Variadic;
+}): ArgSpec<Name, Schema, Variadic>;
+/**
+* Define a flag schema for `defineZodCommand()` with optional alias/description.
+*
+* The `const Alias` parameter preserves alias literals (e.g. `"v"` or
+* `readonly ["v", "V"]`) in the return type, enabling compile-time alias
+* collision detection in `defineZodCommand()`.
+*
+* @param schema - Zod schema
+* @param options - Optional flag metadata
+*/
+declare function flag<
+	Schema extends ZodSchemaLike,
+	const Alias extends string | readonly string[] | undefined = undefined
+>(schema: Schema, options?: FlagOptions & {
+	alias?: Alias;
+}): FlagSpec<Schema, Alias>;
+export { flag, defineZodCommand, arg, ZodSchemaLike, ZodCommandRunHandler, ZodCommandDef, InferSchemaOutput, InferFlagsFromShape, InferFlagsFromConfig, InferArgsFromSpecs, InferArgsFromConfig, FlagSpec, FlagShape, FlagOptions, ArgSpecs, ArgSpec, ArgOptions };

package/dist/zod/index.js

@@ -0,0 +1,255 @@
+// @bun
+import {
+  buildArgDefinitions,
+  buildFlagDefinitions,
+  buildRunHandler,
+  normalizeIssues
+} from "../shared/chunk-zfhm7pmv.js";
+
+// src/zod/command.ts
+import { defineCommand } from "@crustjs/core";
+import { safeParseAsync } from "zod/v4/core";
+
+// src/zod/definitions.ts
+import { CrustError as CrustError2 } from "@crustjs/core";
+
+// src/zod/schema.ts
+import { CrustError } from "@crustjs/core";
+function isZodSchema(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (!("_zod" in value)) {
+    return false;
+  }
+  return true;
+}
+function arg(name, schema, options) {
+  if (!name.trim()) {
+    throw new CrustError("DEFINITION", "arg(): name is required and must be a non-empty string");
+  }
+  if (!isZodSchema(schema)) {
+    throw new CrustError("DEFINITION", `arg("${name}"): schema must be a Zod schema`);
+  }
+  return {
+    kind: "arg",
+    name,
+    schema,
+    variadic: options?.variadic
+  };
+}
+function flag(schema, options) {
+  if (!isZodSchema(schema)) {
+    throw new CrustError("DEFINITION", "flag(): schema must be a Zod schema");
+  }
+  return {
+    kind: "flag",
+    schema,
+    alias: options?.alias
+  };
+}
+function resolveDescription(schema) {
+  let current = schema;
+  const seen = new Set;
+  for (;; ) {
+    if (current === undefined || current === null || seen.has(current)) {
+      return;
+    }
+    seen.add(current);
+    if (typeof current !== "object") {
+      return;
+    }
+    if ("description" in current && typeof current.description === "string") {
+      return current.description;
+    }
+    const type = "type" in current ? current.type : undefined;
+    if (typeof type !== "string") {
+      return;
+    }
+    if (type === "pipe" || type === "transform") {
+      const input = current.in;
+      if (input !== undefined) {
+        current = input;
+        continue;
+      }
+      return;
+    }
+    if (type === "optional" || type === "nullable" || type === "default" || type === "prefault" || type === "nonoptional" || type === "readonly" || type === "catch") {
+      const unwrap = current.unwrap;
+      if (typeof unwrap === "function") {
+        current = unwrap();
+        continue;
+      }
+      return;
+    }
+    return;
+  }
+}
+
+// src/zod/definitions.ts
+function asRuntimeSchema(value) {
+  if (typeof value !== "object" || value === null) {
+    return;
+  }
+  return value;
+}
+function getSchemaType(schema) {
+  const runtime = asRuntimeSchema(schema);
+  if (!runtime || typeof runtime.type !== "string") {
+    return;
+  }
+  return runtime.type;
+}
+function unwrapInputSchema(schema) {
+  let current = schema;
+  for (;; ) {
+    const type = getSchemaType(current);
+    const runtime = asRuntimeSchema(current);
+    if (!type || !runtime) {
+      return current;
+    }
+    if (type === "pipe" || type === "transform") {
+      if (runtime.in === undefined) {
+        return current;
+      }
+      current = runtime.in;
+      continue;
+    }
+    if (type === "optional" || type === "nullable" || type === "default" || type === "prefault" || type === "nonoptional" || type === "readonly" || type === "catch") {
+      if (typeof runtime.unwrap !== "function") {
+        return current;
+      }
+      current = runtime.unwrap();
+      continue;
+    }
+    return current;
+  }
+}
+function resolvePrimitiveInputType(schema) {
+  const type = getSchemaType(schema);
+  if (!type) {
+    return;
+  }
+  if (type === "string" || type === "enum") {
+    return "string";
+  }
+  if (type === "number") {
+    return "number";
+  }
+  if (type === "boolean") {
+    return "boolean";
+  }
+  if (type === "literal") {
+    const runtime = asRuntimeSchema(schema);
+    const first = runtime?.values?.values().next().value;
+    if (typeof first === "string") {
+      return "string";
+    }
+    if (typeof first === "number") {
+      return "number";
+    }
+    if (typeof first === "boolean") {
+      return "boolean";
+    }
+  }
+  return;
+}
+function resolveInputShape(schema, label) {
+  const inputSchema = unwrapInputSchema(schema);
+  if (getSchemaType(inputSchema) === "array") {
+    const runtime = asRuntimeSchema(inputSchema);
+    if (typeof runtime?.unwrap !== "function") {
+      throw new CrustError2("DEFINITION", `${label}: unable to inspect array element schema`);
+    }
+    const elementSchema = unwrapInputSchema(runtime.unwrap());
+    const primitive2 = resolvePrimitiveInputType(elementSchema);
+    if (primitive2) {
+      return { type: primitive2, multiple: true };
+    }
+    throw new CrustError2("DEFINITION", `${label}: array element type must be string, number, or boolean`);
+  }
+  const primitive = resolvePrimitiveInputType(inputSchema);
+  if (primitive) {
+    return { type: primitive, multiple: false };
+  }
+  throw new CrustError2("DEFINITION", `${label}: unsupported schema type for CLI parsing. Use string, number, boolean, enum/literal, or array of these.`);
+}
+function isOptionalInputSchema(schema) {
+  let current = schema;
+  for (;; ) {
+    const type = getSchemaType(current);
+    const runtime = asRuntimeSchema(current);
+    if (!type || !runtime) {
+      return false;
+    }
+    if (type === "optional" || type === "default" || type === "prefault" || type === "catch") {
+      return true;
+    }
+    if (type === "pipe" || type === "transform") {
+      if (runtime.in === undefined) {
+        return false;
+      }
+      current = runtime.in;
+      continue;
+    }
+    if (type === "nullable" || type === "nonoptional" || type === "readonly") {
+      if (typeof runtime.unwrap !== "function") {
+        return false;
+      }
+      current = runtime.unwrap();
+      continue;
+    }
+    return false;
+  }
+}
+var zodAdapter = {
+  resolveInputShape,
+  isOptionalInputSchema,
+  resolveDescription,
+  commandLabel: "defineZodCommand",
+  arrayHint: "z.array(...)"
+};
+function argsToDefinitions(args) {
+  return buildArgDefinitions(args, zodAdapter);
+}
+function flagsToDefinitions(flags) {
+  return buildFlagDefinitions(flags, zodAdapter);
+}
+
+// src/zod/command.ts
+async function validateValue(schema, value, prefix) {
+  const parseResult = await safeParseAsync(schema, value);
+  if (parseResult.success) {
+    return { ok: true, value: parseResult.data };
+  }
+  const prefixed = parseResult.error.issues.map((issue) => ({
+    message: issue.message,
+    path: [...prefix, ...issue.path ?? []]
+  }));
+  return { ok: false, issues: normalizeIssues(prefixed) };
+}
+function defineZodCommand(config) {
+  const {
+    args: zodArgs,
+    flags: zodFlags,
+    run: userRun,
+    ...passthrough
+  } = config;
+  const argSpecs = zodArgs ?? [];
+  const generatedArgs = argsToDefinitions(argSpecs);
+  const generatedFlags = flagsToDefinitions(zodFlags);
+  const command = defineCommand({
+    ...passthrough,
+    ...generatedArgs.length > 0 && { args: generatedArgs },
+    ...Object.keys(generatedFlags).length > 0 && { flags: generatedFlags },
+    ...userRun && {
+      run: buildRunHandler(argSpecs, zodFlags, userRun, validateValue)
+    }
+  });
+  return command;
+}
+export {
+  flag,
+  defineZodCommand,
+  arg
+};

package/package.json

@@ -0,0 +1,73 @@
+{
+	"name": "@crustjs/validate",
+	"version": "0.0.1",
+	"description": "Validation helpers for the Crust CLI framework",
+	"type": "module",
+	"license": "MIT",
+	"author": "chenxin-yan",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/chenxin-yan/crust.git",
+		"directory": "packages/validate"
+	},
+	"homepage": "https://crustjs.com",
+	"bugs": {
+		"url": "https://github.com/chenxin-yan/crust/issues"
+	},
+	"keywords": [
+		"cli",
+		"validation",
+		"effect",
+		"zod",
+		"bun",
+		"typescript"
+	],
+	"files": [
+		"dist"
+	],
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		},
+		"./effect": {
+			"import": "./dist/effect/index.js",
+			"types": "./dist/effect/index.d.ts"
+		},
+		"./zod": {
+			"import": "./dist/zod/index.js",
+			"types": "./dist/zod/index.d.ts"
+		}
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "bunup",
+		"dev": "bunup --watch",
+		"check:types": "tsc --noEmit",
+		"test": "bun test"
+	},
+	"devDependencies": {
+		"@crustjs/config": "0.0.0",
+		"@crustjs/core": "0.0.6",
+		"@crustjs/plugins": "0.0.6",
+		"bunup": "^0.16.29",
+		"effect": "^3.19.0",
+		"zod": "^4.0.0"
+	},
+	"peerDependencies": {
+		"@crustjs/core": "0.0.6",
+		"effect": "^3.19.0",
+		"zod": "^4.0.0",
+		"typescript": "^5"
+	},
+	"peerDependenciesMeta": {
+		"effect": {
+			"optional": true
+		},
+		"zod": {
+			"optional": true
+		}
+	}
+}