@wentools/zli 0.2.0-beta.2dc33a43

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 wentools
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,226 @@
+# @wentools/zli
+
+Lightweight CLI builder with Zod validation and type-safe argument parsing.
+
+## Installation
+
+```bash
+npx jsr add @wentools/zli
+pnpm add zod@4
+```
+
+## Features
+
+- **Type-safe arguments** inferred from Zod schemas
+- **Flexible parsing**: positional args by order OR by `--name`
+- **Short flags**: `--verbose` or `-v`
+- **Copy-paste friendly**: easy to expand from simple to multi-command scripts
+- **Auto-generated help text**
+- **Pretty validation error messages**
+- **Conflict detection** for duplicate names/shorts
+- **Result integration** for error handling
+
+## Quick Start
+
+### Simple Single Command
+
+```typescript
+import { zli } from '@wentools/zli'
+import { z } from 'zod'
+
+const command = zli.c(
+  [
+    zli.p('email', z.string().email(), {
+      description: 'User email address',
+      short: 'e'
+    }),
+    zli.f('verbose', z.boolean().optional().default(false), {
+      description: 'Verbose output',
+      short: 'v'
+    })
+  ],
+  (args) => {
+    console.log(args.email)    // typed as string
+    console.log(args.verbose)  // typed as boolean
+  },
+  { description: 'Check user permissions' }
+)
+
+zli.run(command)
+```
+
+**Invocation:**
+
+```bash
+# Positional
+pnpm tsx script.ts user@example.com
+
+# Named
+pnpm tsx script.ts --email user@example.com
+
+# Short flag
+pnpm tsx script.ts -e user@example.com
+
+# With flags
+pnpm tsx script.ts user@example.com --verbose
+
+# Help
+pnpm tsx script.ts --help
+```
+
+### Multi-Command Script
+
+```typescript
+import { zli } from '@wentools/zli'
+import { z } from 'zod'
+
+const check = zli.c(
+  [zli.p('email', z.string().email())],
+  (args) => console.log(`Checking ${args.email}`),
+  { description: 'Check user permissions' }
+)
+
+const promote = zli.c(
+  [zli.p('email', z.string().email())],
+  (args) => console.log(`Promoting ${args.email}`),
+  { description: 'Promote user to admin' }
+)
+
+zli.run({
+  name: 'user',
+  description: 'User management commands',
+  commands: {
+    check,
+    promote
+  }
+})
+```
+
+### Nested Command Directories
+
+```typescript
+const cli = zli.d('app', {
+  description: 'Application CLI',
+  commands: {
+    db: zli.d('db', {
+      description: 'Database commands',
+      commands: {
+        migrate: zli.c([], () => console.log('Migrating...')),
+        seed: zli.c([], () => console.log('Seeding...')),
+      }
+    }),
+    version: zli.c([], () => console.log('1.0.0'))
+  }
+})
+
+zli.run(cli)
+```
+
+**Usage:**
+
+```bash
+pnpm tsx script.ts db migrate
+pnpm tsx script.ts db --help
+pnpm tsx script.ts version
+```
+
+## API
+
+### `zli.p(name, schema, options?)` - Positional Argument
+
+Creates a positional argument that can be specified by position, `--name`, or `-short`.
+
+```typescript
+zli.p('email', z.string().email(), {
+  short: 'e',
+  description: 'User email address'
+})
+```
+
+### `zli.f(name, schema, options?)` - Flag Argument
+
+Creates a flag argument specified with `--name` or `-short`.
+
+```typescript
+zli.f('verbose', z.boolean().optional().default(false), {
+  short: 'v',
+  description: 'Enable verbose output'
+})
+```
+
+### `zli.c(args, handler, options?)` - Command
+
+Creates a command with arguments and handler.
+
+```typescript
+zli.c(
+  [zli.p('name', z.string())],
+  async (args) => {
+    // Handler can be sync or async
+    // Can return void or Result
+  },
+  { description: 'Command description' }
+)
+```
+
+### `zli.d(name, options)` - Command Directory
+
+Creates a directory of commands for hierarchical organization.
+
+```typescript
+zli.d('admin', {
+  description: 'Admin commands',
+  commands: {
+    users: usersDirectory,
+    config: configCommand
+  }
+})
+```
+
+### `zli.run(input)` - Execute CLI
+
+Runs a command or command directory.
+
+## Error Handling with Results
+
+Handlers can return `Result` types from `@wentools/result`:
+
+```typescript
+import { err } from '@wentools/result'
+
+const command = zli.c(
+  [zli.p('email', z.string().email())],
+  async (args) => {
+    const user = await findUser(args.email)
+    if (!user) {
+      return err('user_not_found', 'User not found')
+    }
+    console.log(`Found: ${user.name}`)
+  }
+)
+```
+
+If the handler returns `err()`, zli will:
+- Log the error as JSON
+- Exit with code 1
+
+## Argument Parsing Behavior
+
+- Positional args fill slots left-to-right
+- Named flags (`--name` or `-short`) can fill any slot
+- Explicit (named) overrides implicit (positional)
+
+```bash
+# These are equivalent:
+script.ts user@example.com
+script.ts --email user@example.com
+script.ts -e user@example.com
+
+# Override positional with flag:
+script.ts wrong@example.com --email correct@example.com
+# Result: args.email = "correct@example.com"
+```
+
+## License
+
+MIT

package/esm/_dnt.shims.d.ts

@@ -0,0 +1,6 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
+    Deno: typeof Deno;
+};
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/esm/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAKvC,eAAO,MAAM,aAAa;;CAA2C,CAAC"}

package/esm/_dnt.shims.js

@@ -0,0 +1,61 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+const dntGlobals = {
+    Deno,
+};
+export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/esm/arg.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Arg type - union of positional and flag args
+ */
+import type { PositionalArg } from './create_positional_arg.js';
+import type { FlagArg } from './create_flag_arg.js';
+import type { ZodSchema } from 'zod';
+type Arg = PositionalArg<ZodSchema> | FlagArg<ZodSchema>;
+export type { Arg };
+//# sourceMappingURL=arg.d.ts.map

package/esm/arg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arg.d.ts","sourceRoot":"","sources":["../src/arg.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC/D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AAEpC,KAAK,GAAG,GAAG,aAAa,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC,CAAA;AAExD,YAAY,EAAE,GAAG,EAAE,CAAA"}

package/esm/arg.js

@@ -0,0 +1,4 @@
+/**
+ * Arg type - union of positional and flag args
+ */
+export {};

package/esm/create_command.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Create a command configuration
+ *
+ * A command consists of:
+ * - Args (positional and flags)
+ * - Handler function (sync or async)
+ * - Optional description
+ *
+ * Type inference: The handler args are automatically typed based on the Zod schemas
+ * in the args array. This provides full autocomplete and type safety.
+ */
+import type { Arg } from './arg.js';
+import type { InferArgsType } from './infer_args_type.js';
+import type { Result } from './deps/jsr.io/@wentools/result/0.1.0/src/index.js';
+type MaybeResult<TValue = void, TError = unknown> = TValue | Result<TValue, TError>;
+type CommandHandler<TArgs> = (args: TArgs) => MaybeResult<void> | Promise<MaybeResult<void>>;
+type Command<TArgs extends readonly Arg[] = readonly Arg[]> = {
+    args: TArgs;
+    handler: CommandHandler<InferArgsType<TArgs>>;
+    description?: string;
+};
+type CommandOptions = {
+    description?: string;
+};
+declare const createCommand: <const TArgs extends readonly Arg[]>(args: TArgs, handler: CommandHandler<InferArgsType<TArgs>>, options?: CommandOptions) => Command<TArgs>;
+export { createCommand };
+export type { Command, CommandHandler, CommandOptions, MaybeResult };
+//# sourceMappingURL=create_command.d.ts.map

package/esm/create_command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_command.d.ts","sourceRoot":"","sources":["../src/create_command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mDAAmD,CAAA;AAE/E,KAAK,WAAW,CAAC,MAAM,GAAG,IAAI,EAAE,MAAM,GAAG,OAAO,IAAI,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAEnF,KAAK,cAAc,CAAC,KAAK,IAAI,CAAC,IAAI,EAAE,KAAK,KAAK,WAAW,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAA;AAE5F,KAAK,OAAO,CAAC,KAAK,SAAS,SAAS,GAAG,EAAE,GAAG,SAAS,GAAG,EAAE,IAAI;IAC7D,IAAI,EAAE,KAAK,CAAA;IACX,OAAO,EAAE,cAAc,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAA;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,KAAK,cAAc,GAAG;IACrB,WAAW,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,QAAA,MAAM,aAAa,GAAI,KAAK,CAAC,KAAK,SAAS,SAAS,GAAG,EAAE,EACxD,MAAM,KAAK,EACX,SAAS,cAAc,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,EAC7C,UAAU,cAAc,KACtB,OAAO,CAAC,KAAK,CAId,CAAA;AAEF,OAAO,EAAE,aAAa,EAAE,CAAA;AACxB,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,WAAW,EAAE,CAAA"}

package/esm/create_command.js

@@ -0,0 +1,17 @@
+/**
+ * Create a command configuration
+ *
+ * A command consists of:
+ * - Args (positional and flags)
+ * - Handler function (sync or async)
+ * - Optional description
+ *
+ * Type inference: The handler args are automatically typed based on the Zod schemas
+ * in the args array. This provides full autocomplete and type safety.
+ */
+const createCommand = (args, handler, options) => ({
+    args,
+    handler,
+    description: options?.description,
+});
+export { createCommand };

package/esm/create_command_directory.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Create a command directory configuration
+ *
+ * A command directory can contain both leaf commands and nested directories,
+ * allowing for hierarchical CLI organization.
+ *
+ * Think of it like a file system:
+ * - zli.c() = executable file (does work)
+ * - zli.d() = directory (organizes commands)
+ *
+ * @example
+ * const collaborators = zli.d('collaborators', {
+ *   description: 'Manage collaborators',
+ *   commands: {
+ *     add: addCommand,
+ *     remove: removeCommand,
+ *   }
+ * })
+ */
+import type { CommandEntry } from './run.js';
+type CommandDirectory = {
+    name: string;
+    description?: string;
+    commands: Record<string, CommandEntry>;
+};
+type CommandDirectoryOptions = {
+    description?: string;
+    commands: Record<string, CommandEntry>;
+};
+declare const createCommandDirectory: <const TCommands extends Record<string, CommandEntry>>(name: string, options: CommandDirectoryOptions & {
+    commands: TCommands;
+}) => CommandDirectory;
+export { createCommandDirectory };
+export type { CommandDirectory, CommandDirectoryOptions };
+//# sourceMappingURL=create_command_directory.d.ts.map

package/esm/create_command_directory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_command_directory.d.ts","sourceRoot":"","sources":["../src/create_command_directory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAE5C,KAAK,gBAAgB,GAAG;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;CACtC,CAAA;AAED,KAAK,uBAAuB,GAAG;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;CACtC,CAAA;AAED,QAAA,MAAM,sBAAsB,GAAI,KAAK,CAAC,SAAS,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EACnF,MAAM,MAAM,EACZ,SAAS,uBAAuB,GAAG;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,KACxD,gBAWF,CAAA;AAED,OAAO,EAAE,sBAAsB,EAAE,CAAA;AACjC,YAAY,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,CAAA"}

package/esm/create_command_directory.js

@@ -0,0 +1,31 @@
+/**
+ * Create a command directory configuration
+ *
+ * A command directory can contain both leaf commands and nested directories,
+ * allowing for hierarchical CLI organization.
+ *
+ * Think of it like a file system:
+ * - zli.c() = executable file (does work)
+ * - zli.d() = directory (organizes commands)
+ *
+ * @example
+ * const collaborators = zli.d('collaborators', {
+ *   description: 'Manage collaborators',
+ *   commands: {
+ *     add: addCommand,
+ *     remove: removeCommand,
+ *   }
+ * })
+ */
+const createCommandDirectory = (name, options) => {
+    // Validation
+    if (Object.keys(options.commands).length === 0) {
+        throw new Error(`Command directory '${name}' must have at least one command`);
+    }
+    return {
+        name,
+        description: options.description,
+        commands: options.commands,
+    };
+};
+export { createCommandDirectory };

package/esm/create_flag_arg.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Create a flag argument configuration
+ *
+ * Flags are specified with -- or - prefix:
+ * - Long name: script.ts --verbose
+ * - Short name: script.ts -v
+ */
+import type { ZodSchema } from 'zod';
+type FlagArg<TSchema extends ZodSchema> = {
+    type: 'flag';
+    name: string;
+    schema: TSchema;
+    short?: string;
+    description?: string;
+};
+type FlagArgOptions = {
+    short?: string;
+    description?: string;
+};
+declare const createFlagArg: <TSchema extends ZodSchema>(name: string, schema: TSchema, options?: FlagArgOptions) => FlagArg<TSchema>;
+export { createFlagArg };
+export type { FlagArg, FlagArgOptions };
+//# sourceMappingURL=create_flag_arg.d.ts.map

package/esm/create_flag_arg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_flag_arg.d.ts","sourceRoot":"","sources":["../src/create_flag_arg.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AAEpC,KAAK,OAAO,CAAC,OAAO,SAAS,SAAS,IAAI;IACzC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,OAAO,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,KAAK,cAAc,GAAG;IACrB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,QAAA,MAAM,aAAa,GAAI,OAAO,SAAS,SAAS,EAC/C,MAAM,MAAM,EACZ,QAAQ,OAAO,EACf,UAAU,cAAc,KACtB,OAAO,CAAC,OAAO,CAKhB,CAAA;AAEF,OAAO,EAAE,aAAa,EAAE,CAAA;AACxB,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/esm/create_flag_arg.js

@@ -0,0 +1,14 @@
+/**
+ * Create a flag argument configuration
+ *
+ * Flags are specified with -- or - prefix:
+ * - Long name: script.ts --verbose
+ * - Short name: script.ts -v
+ */
+const createFlagArg = (name, schema, options) => ({
+    type: 'flag',
+    name,
+    schema,
+    ...options,
+});
+export { createFlagArg };

package/esm/create_positional_arg.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Create a positional argument configuration
+ *
+ * Positional args can be specified:
+ * - By position: script.ts value
+ * - By long name: script.ts --name value
+ * - By short name: script.ts -n value
+ */
+import type { ZodSchema } from 'zod';
+type PositionalArg<TSchema extends ZodSchema> = {
+    type: 'positional';
+    name: string;
+    schema: TSchema;
+    short?: string;
+    description?: string;
+};
+type PositionalArgOptions = {
+    short?: string;
+    description?: string;
+};
+declare const createPositionalArg: <TSchema extends ZodSchema>(name: string, schema: TSchema, options?: PositionalArgOptions) => PositionalArg<TSchema>;
+export { createPositionalArg };
+export type { PositionalArg, PositionalArgOptions };
+//# sourceMappingURL=create_positional_arg.d.ts.map

package/esm/create_positional_arg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_positional_arg.d.ts","sourceRoot":"","sources":["../src/create_positional_arg.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AAEpC,KAAK,aAAa,CAAC,OAAO,SAAS,SAAS,IAAI;IAC/C,IAAI,EAAE,YAAY,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,OAAO,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,KAAK,oBAAoB,GAAG;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,QAAA,MAAM,mBAAmB,GAAI,OAAO,SAAS,SAAS,EACrD,MAAM,MAAM,EACZ,QAAQ,OAAO,EACf,UAAU,oBAAoB,KAC5B,aAAa,CAAC,OAAO,CAKtB,CAAA;AAEF,OAAO,EAAE,mBAAmB,EAAE,CAAA;AAC9B,YAAY,EAAE,aAAa,EAAE,oBAAoB,EAAE,CAAA"}

package/esm/create_positional_arg.js

@@ -0,0 +1,15 @@
+/**
+ * Create a positional argument configuration
+ *
+ * Positional args can be specified:
+ * - By position: script.ts value
+ * - By long name: script.ts --name value
+ * - By short name: script.ts -n value
+ */
+const createPositionalArg = (name, schema, options) => ({
+    type: 'positional',
+    name,
+    schema,
+    ...options,
+});
+export { createPositionalArg };

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/err/err.d.ts

@@ -0,0 +1,38 @@
+import { type Err } from 'neverthrow';
+/**
+ * Create an Err Result with automatic literal type preservation
+ *
+ * Uses TypeScript 5.0+ const type parameters to preserve literal types automatically.
+ * No need for 'as const' - the type parameter is inferred as a literal!
+ *
+ * Returns Err<never, E> (not Result<never, E>) so .error is directly accessible.
+ *
+ * @example
+ * // ✅ Simple error
+ * return err('not_found', 'User not found')
+ * // Type: Err<never, { type: 'not_found', message: string }>
+ *
+ * @example
+ * // ✅ Error with additional properties
+ * return err('not_found', 'User not found', { userId: '123' })
+ * // Type: Err<never, { type: 'not_found', message: string, userId: string }>
+ *
+ * @example
+ * // ✅ Direct .error access (no narrowing needed)
+ * const error = err('not_found', 'User not found').error
+ * // error.type is 'not_found'
+ *
+ * @example
+ * // ✅ Error with complex additional data
+ * return err('validation_failed', 'Invalid input', {
+ *   field: 'email',
+ *   errors: ['Invalid format']
+ * })
+ * // Type: Err<never, { type: 'validation_failed', message: string, field: string, errors: string[] }>
+ */
+declare const err: <const TType extends string, TAdditional extends Record<string, unknown> = Record<string, never>>(type: TType, message: string, additional?: TAdditional) => Err<never, {
+    type: TType;
+    message: string;
+} & TAdditional>;
+export { err };
+//# sourceMappingURL=err.d.ts.map

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/err/err.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"err.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@wentools/result/0.1.0/src/err/err.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,GAAG,EAAE,MAAM,YAAY,CAAA;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,QAAA,MAAM,GAAG,GACR,KAAK,CAAC,KAAK,SAAS,MAAM,EAC1B,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAEnE,MAAM,KAAK,EACX,SAAS,MAAM,EACf,aAAa,WAAW,KACtB,GAAG,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,WAAW,CAKP,CAAA;AAErD,OAAO,EAAE,GAAG,EAAE,CAAA"}

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/err/err.js

@@ -0,0 +1,38 @@
+import { err as _Err } from 'neverthrow';
+/**
+ * Create an Err Result with automatic literal type preservation
+ *
+ * Uses TypeScript 5.0+ const type parameters to preserve literal types automatically.
+ * No need for 'as const' - the type parameter is inferred as a literal!
+ *
+ * Returns Err<never, E> (not Result<never, E>) so .error is directly accessible.
+ *
+ * @example
+ * // ✅ Simple error
+ * return err('not_found', 'User not found')
+ * // Type: Err<never, { type: 'not_found', message: string }>
+ *
+ * @example
+ * // ✅ Error with additional properties
+ * return err('not_found', 'User not found', { userId: '123' })
+ * // Type: Err<never, { type: 'not_found', message: string, userId: string }>
+ *
+ * @example
+ * // ✅ Direct .error access (no narrowing needed)
+ * const error = err('not_found', 'User not found').error
+ * // error.type is 'not_found'
+ *
+ * @example
+ * // ✅ Error with complex additional data
+ * return err('validation_failed', 'Invalid input', {
+ *   field: 'email',
+ *   errors: ['Invalid format']
+ * })
+ * // Type: Err<never, { type: 'validation_failed', message: string, field: string, errors: string[] }>
+ */
+const err = (type, message, additional) => _Err({
+    ...additional,
+    type,
+    message,
+});
+export { err };

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/err/index.d.ts

@@ -0,0 +1,2 @@
+export { err } from './err.js';
+//# sourceMappingURL=index.d.ts.map

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/err/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@wentools/result/0.1.0/src/err/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA"}

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/err/index.js

@@ -0,0 +1 @@
+export { err } from './err.js';