@wentools/zli 0.2.0-beta.2dc33a43

package/script/_dnt.shims.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = exports.Deno = void 0;
+const shim_deno_1 = require("@deno/shim-deno");
+var shim_deno_2 = require("@deno/shim-deno");
+Object.defineProperty(exports, "Deno", { enumerable: true, get: function () { return shim_deno_2.Deno; } });
+const dntGlobals = {
+    Deno: shim_deno_1.Deno,
+};
+exports.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/script/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/script/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/script/arg.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Arg type - union of positional and flag args
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/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/script/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/script/create_command.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommand = void 0;
+const createCommand = (args, handler, options) => ({
+    args,
+    handler,
+    description: options?.description,
+});
+exports.createCommand = createCommand;

package/script/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/script/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/script/create_command_directory.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * 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,
+ *   }
+ * })
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommandDirectory = void 0;
+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,
+    };
+};
+exports.createCommandDirectory = createCommandDirectory;

package/script/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/script/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/script/create_flag_arg.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Create a flag argument configuration
+ *
+ * Flags are specified with -- or - prefix:
+ * - Long name: script.ts --verbose
+ * - Short name: script.ts -v
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFlagArg = void 0;
+const createFlagArg = (name, schema, options) => ({
+    type: 'flag',
+    name,
+    schema,
+    ...options,
+});
+exports.createFlagArg = createFlagArg;

package/script/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/script/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/script/create_positional_arg.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPositionalArg = void 0;
+const createPositionalArg = (name, schema, options) => ({
+    type: 'positional',
+    name,
+    schema,
+    ...options,
+});
+exports.createPositionalArg = createPositionalArg;

package/script/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/script/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/script/deps/jsr.io/@wentools/result/0.1.0/src/err/err.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.err = void 0;
+const neverthrow_1 = require("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) => (0, neverthrow_1.err)({
+    ...additional,
+    type,
+    message,
+});
+exports.err = err;

package/script/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/script/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/script/deps/jsr.io/@wentools/result/0.1.0/src/err/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.err = void 0;
+var err_js_1 = require("./err.js");
+Object.defineProperty(exports, "err", { enumerable: true, get: function () { return err_js_1.err; } });

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

@@ -0,0 +1,156 @@
+import { err as _Err, ok, type Result, type Err, ResultAsync, okAsync as neverthrowOkAsync } from 'neverthrow';
+/**
+ * Create an error object with literal type preservation
+ *
+ * @example
+ * const error = makeErr('not_found', 'User not found')
+ * // ✅ Type: { type: 'not_found', message: string }
+ *
+ * @example
+ * const error = makeErr('not_found', 'User not found', { userId: '123' })
+ * // ✅ Type: { type: 'not_found', message: string, userId: string }
+ */
+declare const makeErr: <const TType extends string, TAdditional extends Record<string, unknown> = Record<string, never>>(type: TType, message: string, additional?: TAdditional) => {
+    type: TType;
+    message: string;
+} & TAdditional;
+/**
+ * Create an async Err ResultAsync with automatic literal type preservation
+ *
+ * Async version of err() - same signature, returns ResultAsync instead of Result.
+ * Uses TypeScript 5.0+ const type parameters to preserve literal types automatically.
+ *
+ * @example
+ * // ✅ Simple error
+ * return errAsync('not_found', 'User not found')
+ * // Type: ResultAsync<never, { type: 'not_found', message: string }>
+ *
+ * @example
+ * // ✅ Error with additional properties
+ * return errAsync('not_found', 'User not found', { userId: '123' })
+ * // Type: ResultAsync<never, { type: 'not_found', message: string, userId: string }>
+ *
+ * @example
+ * // ✅ Error with complex additional data
+ * return errAsync('validation_failed', 'Invalid input', {
+ *   field: 'email',
+ *   errors: ['Invalid format']
+ * })
+ * // Type: ResultAsync<never, { type: 'validation_failed', message: string, field: string, errors: string[] }>
+ */
+declare const errAsync: <const TType extends string, TAdditional extends Record<string, unknown> = Record<string, never>>(type: TType, message: string, additional?: TAdditional) => ResultAsync<never, {
+    type: TType;
+    message: string;
+} & TAdditional>;
+/**
+ * Re-export okAsync from neverthrow for consistency
+ * Creates a successful ResultAsync
+ */
+declare const okAsync: typeof neverthrowOkAsync;
+/**
+ * Utility type for defining error types concisely
+ *
+ * @example
+ * // Instead of:
+ * type UserNotFoundError = {
+ *   type: 'user_not_found'
+ *   message: string
+ *   userId: UserId
+ * }
+ *
+ * // Write:
+ * type UserNotFoundError = ErrorType<'user_not_found', { userId: UserId }>
+ *
+ * @example
+ * // Error without additional properties:
+ * type InvalidOperationError = ErrorType<'invalid_operation'>
+ */
+type ErrorType<TType extends string, TAdditional extends Record<string, unknown> = Record<string, never>> = {
+    type: TType;
+    message: string;
+} & TAdditional;
+/**
+ * Extract the error type from a Result or Promise<Result>
+ *
+ * @example
+ * // From async function
+ * const getUser = async (id: string): Promise<Result<User, UserNotFoundError>> => { ... }
+ * type GetUserError = ExtractError<ReturnType<typeof getUser>>
+ * // Type: UserNotFoundError
+ *
+ * @example
+ * // From Result type directly
+ * type MyResult = Result<User, InvalidError>
+ * type MyError = ExtractError<MyResult>
+ * // Type: InvalidError
+ *
+ * @example
+ * // Works with composed errors
+ * const replaceVersion = async (): Promise<Result<Version, VersionNotFoundError | VersionExistsError>> => { ... }
+ * type ReplaceError = ExtractError<ReturnType<typeof replaceVersion>>
+ * // Type: VersionNotFoundError | VersionExistsError
+ */
+type ExtractError<TResultOrPromise> = TResultOrPromise extends Promise<Result<unknown, infer TError>> ? TError : TResultOrPromise extends Result<unknown, infer TError> ? TError : never;
+/**
+ * Extract the error type from a function that returns Result or Promise<Result>
+ *
+ * @example
+ * // Simple extraction
+ * const getUser = async (id: string): Promise<Result<User, UserNotFoundError>> => { ... }
+ * type GetUserError = ExtractFnError<typeof getUser>
+ * // Type: UserNotFoundError
+ *
+ * @example
+ * // Compose errors from multiple functions
+ * const getUser = async (id: string): Promise<Result<User, UserNotFoundError>> => { ... }
+ * const getImage = async (id: string): Promise<Result<Image, ImageNotFoundError>> => { ... }
+ * type CombinedError = ExtractFnError<typeof getUser> | ExtractFnError<typeof getImage>
+ * // Type: UserNotFoundError | ImageNotFoundError
+ */
+type ExtractFnError<TFunction extends (...args: unknown[]) => unknown> = ExtractError<ReturnType<TFunction>>;
+/**
+ * Extract and combine error types from multiple Result or Promise<Result> types
+ *
+ * @example
+ * type UserResult = Result<User, UserNotFoundError>
+ * type ImageResult = Promise<Result<Image, ImageNotFoundError>>
+ * type ProductResult = Result<Product, ProductNotFoundError>
+ *
+ * type CombinedError = ExtractErrors<[UserResult, ImageResult, ProductResult]>
+ * // Type: UserNotFoundError | ImageNotFoundError | ProductNotFoundError
+ */
+type ExtractErrors<TResults extends readonly unknown[]> = TResults extends readonly [
+    infer TFirst,
+    ...infer TRest
+] ? ExtractError<TFirst> | ExtractErrors<TRest> : never;
+/**
+ * Extract and combine error types from multiple functions that return Result or Promise<Result>
+ *
+ * @example
+ * const getUser = async (id: string): Promise<Result<User, UserNotFoundError>> => { ... }
+ * const getImage = async (id: string): Promise<Result<Image, ImageNotFoundError>> => { ... }
+ * const deleteProduct = async (id: string): Promise<Result<void, ProductNotFoundError>> => { ... }
+ *
+ * type CombinedError = ExtractFnsError<[typeof getUser, typeof getImage, typeof deleteProduct]>
+ * // Type: UserNotFoundError | ImageNotFoundError | ProductNotFoundError
+ */
+type ExtractFnsError<TFunctions extends readonly ((...args: unknown[]) => unknown)[]> = TFunctions extends readonly [
+    infer TFirst,
+    ...infer TRest extends readonly ((...args: unknown[]) => unknown)[]
+] ? ExtractFnError<TFirst & ((...args: unknown[]) => unknown)> | ExtractFnsError<TRest> : never;
+/**
+ * Raw error function from neverthrow - use for lifting database errors directly
+ *
+ * @example
+ * const seedResult = await songSeeds.get.one.byId(songSeedId)
+ * if (seedResult.isErr()) {
+ *   return rawErr(seedResult.error)
+ * }
+ */
+declare const rawErr: typeof _Err;
+export { makeErr, errAsync, ok, okAsync, rawErr, _Err, ResultAsync };
+export type { Result, Err, ErrorType, ExtractError, ExtractFnError, ExtractErrors, ExtractFnsError };
+export { err } from './err/index.js';
+export { isResult } from './is_result/index.js';
+export { propagateErr } from './propagate_err/index.js';
+//# sourceMappingURL=index.d.ts.map

package/script/deps/jsr.io/@wentools/result/0.1.0/src/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/index.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propagateErr = exports.isResult = exports.err = exports.ResultAsync = exports._Err = exports.rawErr = exports.okAsync = exports.ok = exports.errAsync = exports.makeErr = void 0;
+const neverthrow_1 = require("neverthrow");
+Object.defineProperty(exports, "_Err", { enumerable: true, get: function () { return neverthrow_1.err; } });
+Object.defineProperty(exports, "ok", { enumerable: true, get: function () { return neverthrow_1.ok; } });
+Object.defineProperty(exports, "ResultAsync", { enumerable: true, get: function () { return neverthrow_1.ResultAsync; } });
+/**
+ * Create an error object with literal type preservation
+ *
+ * @example
+ * const error = makeErr('not_found', 'User not found')
+ * // ✅ Type: { type: 'not_found', message: string }
+ *
+ * @example
+ * const error = makeErr('not_found', 'User not found', { userId: '123' })
+ * // ✅ Type: { type: 'not_found', message: string, userId: string }
+ */
+const makeErr = (type, message, additional) => ({
+    ...additional,
+    type,
+    message,
+});
+exports.makeErr = makeErr;
+/**
+ * Create an async Err ResultAsync with automatic literal type preservation
+ *
+ * Async version of err() - same signature, returns ResultAsync instead of Result.
+ * Uses TypeScript 5.0+ const type parameters to preserve literal types automatically.
+ *
+ * @example
+ * // ✅ Simple error
+ * return errAsync('not_found', 'User not found')
+ * // Type: ResultAsync<never, { type: 'not_found', message: string }>
+ *
+ * @example
+ * // ✅ Error with additional properties
+ * return errAsync('not_found', 'User not found', { userId: '123' })
+ * // Type: ResultAsync<never, { type: 'not_found', message: string, userId: string }>
+ *
+ * @example
+ * // ✅ Error with complex additional data
+ * return errAsync('validation_failed', 'Invalid input', {
+ *   field: 'email',
+ *   errors: ['Invalid format']
+ * })
+ * // Type: ResultAsync<never, { type: 'validation_failed', message: string, field: string, errors: string[] }>
+ */
+const errAsync = (type, message, additional) => (0, neverthrow_1.errAsync)({
+    ...additional,
+    type,
+    message,
+});
+exports.errAsync = errAsync;
+/**
+ * Re-export okAsync from neverthrow for consistency
+ * Creates a successful ResultAsync
+ */
+const okAsync = neverthrow_1.okAsync;
+exports.okAsync = okAsync;
+/**
+ * Raw error function from neverthrow - use for lifting database errors directly
+ *
+ * @example
+ * const seedResult = await songSeeds.get.one.byId(songSeedId)
+ * if (seedResult.isErr()) {
+ *   return rawErr(seedResult.error)
+ * }
+ */
+const rawErr = neverthrow_1.err;
+exports.rawErr = rawErr;
+var index_js_1 = require("./err/index.js");
+Object.defineProperty(exports, "err", { enumerable: true, get: function () { return index_js_1.err; } });
+var index_js_2 = require("./is_result/index.js");
+Object.defineProperty(exports, "isResult", { enumerable: true, get: function () { return index_js_2.isResult; } });
+var index_js_3 = require("./propagate_err/index.js");
+Object.defineProperty(exports, "propagateErr", { enumerable: true, get: function () { return index_js_3.propagateErr; } });

package/script/deps/jsr.io/@wentools/result/0.1.0/src/is_result/index.d.ts

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