@blade-hq/agent-client 1.1.1 → 1.1.3

package/node_modules/arktype/README.md

@@ -0,0 +1,157 @@
+<h1 align="center">ArkType</h1>
+<h3 align="center"><i>TypeScript's 1:1 validator, optimized from editor to runtime</i></h1>
+
+ArkType is a runtime validation library that parses optimized validators from familiar, type-safe syntax.
+
+It can be used to check external data like JSON payloads or forms at the boundaries of your code (similar to Zod).
+
+<video
+autoPlay
+loop
+controls
+playsInline
+muted
+disablePictureInPicture
+src="https://github.com/user-attachments/assets/69fdded6-50a9-402d-a28c-afa58db63c90"
+/>
+
+## Docs
+
+See our [docs site](https://arktype.io)
+
+## Contributions
+
+We accept and encourage pull requests from outside ArkType. Planned work is tracked in [this GitHub project](https://github.com/orgs/arktypeio/projects/4).
+
+Depending on your level of familiarity with type systems and TS generics, some parts of the codebase may be hard to jump into. That said, there's plenty of opportunities for more straightforward contributions. We'd generally recommend starting with one of these issues labeled [external-contributor-friendly](https://github.com/orgs/arktypeio/projects/4/?filterQuery=label%3A%22external-contributor-friendly%22).
+
+If you're planning on submitting a non-trivial fix or a new feature, please [create an issue first](https://github.com/arktypeio/arktype/issues/new) so everyone's on the same page. The last thing we want is for you to spend time on a submission we're unable to merge.
+
+When you're ready, check out our [guide](./.github/CONTRIBUTING.md) to get started!
+
+## License
+
+This project is licensed under the terms of the
+[MIT license](./LICENSE).
+
+## Code of Conduct
+
+We will not tolerate any form of disrespect toward members of our community. Please refer to our [Code of Conduct](./.github/CODE_OF_CONDUCT.md) and reach out to david@arktype.io immediately if you've seen or experienced an interaction that may violate these standards.
+
+## Sponsorship
+
+We've been working full-time on this project for multiple years and it means a lot to have the community behind us.
+
+If the project has been useful to you and you are in a financial position to do so, please chip in via [GitHub Sponsors](https://github.com/sponsors/arktypeio).
+
+Otherwise, consider sending me an email (david@arktype.io) or [message me on Discord](https://arktype.io/discord) to let me know you're a fan of ArkType. Either would make my day!
+
+### ArkSponsors ⛵
+
+<table>
+    <tr>
+        <th>get-convex</th>
+        <th>inspatiallabs</th>
+        <th>sam-goodwin</th>
+    </tr>
+    <tr>
+        <td>
+            <a href="https://github.com/get-convex"
+                ><img
+                    height="64px"
+                    src="https://avatars.githubusercontent.com/get-convex"
+            /></a>
+        </td>
+        <td>
+            <a href="https://github.com/inspatiallabs"
+                ><img
+                    height="64px"
+                    src="https://avatars.githubusercontent.com/inspatiallabs"
+            /></a>
+        </td>
+        <td>
+            <a href="https://github.com/sam-goodwin"
+                ><img
+                    height="64px"
+                    src="https://avatars.githubusercontent.com/sam-goodwin"
+            /></a>
+        </td>
+    </tr>
+</table>
+
+### Sponsors 🥰
+
+<table>
+    <tr>
+        <th>tmm</th>
+        <th>mewhhaha</th>
+        <th>jahands</th>
+        <th>drwpwrs</th>
+        <th>Phalangers</th>
+    </tr>
+    <tr>
+        <td>
+            <a href="https://github.com/tmm"
+                ><img
+                    height="64px"
+                    src="https://avatars.githubusercontent.com/tmm"
+            /></a>
+        </td>
+        <td>
+            <a href="https://github.com/mewhhaha"
+                ><img
+                    height="64px"
+                    src="https://avatars.githubusercontent.com/mewhhaha"
+            /></a>
+        </td>
+        <td>
+            <a href="https://github.com/jahands"
+                ><img
+                    height="64px"
+                    src="https://avatars.githubusercontent.com/jahands"
+            /></a>
+        </td>
+        <td>
+            <a href="https://github.com/drwpwrs"
+                ><img
+                    height="64px"
+                    src="https://avatars.githubusercontent.com/drwpwrs"
+            /></a>
+        </td>
+        <td>
+            <a href="https://github.com/Phalangers"
+                ><img
+                    height="64px"
+                    src="https://avatars.githubusercontent.com/Phalangers"
+            /></a>
+        </td>
+    </tr>
+    <tr>
+        <th>WilliamConnatser</th>
+        <th>JameEnder</th>
+        <th>tylim88</th>
+    </tr>
+    <tr>
+        <td>
+            <a href="https://github.com/WilliamConnatser"
+                ><img
+                    height="64px"
+                    src="https://avatars.githubusercontent.com/WilliamConnatser"
+            /></a>
+        </td>
+        <td>
+            <a href="https://github.com/JameEnder"
+                ><img
+                    height="64px"
+                    src="https://avatars.githubusercontent.com/JameEnder"
+            /></a>
+        </td>
+        <td>
+            <a href="https://github.com/tylim88"
+                ><img
+                    height="64px"
+                    src="https://avatars.githubusercontent.com/tylim88"
+            /></a>
+        </td>
+    </tr>
+</table>

package/node_modules/arktype/out/attributes.d.ts

@@ -0,0 +1,104 @@
+import type { ArkError, ArkErrors, Morph } from "@ark/schema";
+import { type anyOrNever, type array, type Brand, type equals, type Hkt, type intersectArrays, type isSafelyMappable, type merge, type optionalKeyOf, type Primitive, type show, type unionKeyOf, type unionToTuple } from "@ark/util";
+import type { arkPrototypes } from "./keywords/constructors.ts";
+import type { type } from "./keywords/keywords.ts";
+import type { Type } from "./type.ts";
+export type { arkPrototypes as object } from "./keywords/constructors.ts";
+export type Comparator = "<" | "<=" | ">" | ">=" | "==";
+export type RegexLiteral<source extends string = string> = `/${source}/`;
+export type DateLiteral<source extends string = string> = `d"${source}"` | `d'${source}'`;
+export type LimitLiteral = number | DateLiteral;
+export type normalizeLimit<limit> = limit extends DateLiteral<infer source> ? source : limit extends number | string ? limit : never;
+export type distill<t, side extends distill.Side> = finalizeDistillation<t, _distill<t, side>>;
+export declare namespace distill {
+    type Side = "in" | "out" | "introspectableOut";
+    type In<t> = distill<t, "in">;
+    type Out<t> = distill<t, "out">;
+    namespace introspectable {
+        type Out<t> = distill<t, "introspectableOut">;
+    }
+}
+type finalizeDistillation<t, distilled> = equals<t, distilled> extends true ? t : distilled;
+type _distill<t, side extends distill.Side> = t extends undefined ? t : [t] extends [anyOrNever] ? t : unknown extends t ? unknown : t extends Brand<infer base> ? side extends "in" ? base : t : t extends TerminallyInferredObject | Primitive ? t : t extends Function ? t extends (...args: never) => anyOrNever ? t : t extends InferredMorph<infer i, infer o> ? distillIo<i, o, side> : t : t extends Default<infer constraint> ? _distill<constraint, side> : t extends array ? distillArray<t, side> : isSafelyMappable<t> extends true ? distillMappable<t, side> : t;
+type distillMappable<o, side extends distill.Side> = side extends "in" ? show<{
+    [k in keyof o as k extends inferredDefaultKeyOf<o> ? never : k]: _distill<o[k], side>;
+} & {
+    [k in inferredDefaultKeyOf<o>]?: _distill<o[k], side>;
+}> : {
+    [k in keyof o]: _distill<o[k], side>;
+};
+type distillIo<i, o extends Out, side extends distill.Side> = side extends "out" ? _distill<o["t"], side> : side extends "in" ? _distill<i, side> : o extends To<infer validatedOut> ? _distill<validatedOut, side> : unknown;
+type unwrapInput<t> = t extends InferredMorph<infer i> ? t extends anyOrNever ? t : i : t;
+type inferredDefaultKeyOf<o> = keyof o extends infer k ? k extends keyof o ? unwrapInput<o[k]> extends Default<infer t> ? [
+    t
+] extends [anyOrNever] ? never : k : never : never : never;
+type distillArray<t extends array, side extends distill.Side> = t[number][] extends t ? alignReadonly<_distill<t[number], side>[], t> : distillNonArraykeys<t, alignReadonly<distillArrayFromPrefix<[...t], side, []>, t>, side>;
+type alignReadonly<result extends unknown[], original extends array> = original extends unknown[] ? result : Readonly<result>;
+type distillNonArraykeys<originalArray extends array, distilledArray, side extends distill.Side> = keyof originalArray extends keyof distilledArray ? distilledArray : distilledArray & _distill<{
+    [k in keyof originalArray as k extends keyof distilledArray ? never : k]: originalArray[k];
+}, side>;
+type distillArrayFromPrefix<t extends array, side extends distill.Side, prefix extends array> = t extends readonly [infer head, ...infer tail] ? distillArrayFromPrefix<tail, side, [
+    side,
+    head
+] extends ["in", Default] ? [...prefix, _distill<head, side>?] : [...prefix, _distill<head, side>]> : [...prefix, ...distillArrayFromPostfix<t, side, []>];
+type distillArrayFromPostfix<t extends array, side extends distill.Side, postfix extends array> = t extends readonly [...infer init, infer last] ? distillArrayFromPostfix<init, side, [_distill<last, side>, ...postfix]> : [...{
+    [i in keyof t]: _distill<t[i], side>;
+}, ...postfix];
+type BuiltinTerminalObjectKind = Exclude<arkPrototypes.NonDegenerateName, "Array" | "Function">;
+/** Objects we don't want to expand during inference like Date or Promise */
+type TerminallyInferredObject = arkPrototypes.instanceOf<BuiltinTerminalObjectKind> | ArkEnv.prototypes;
+export type inferPredicate<t, predicate> = predicate extends (data: any, ...args: any[]) => data is infer narrowed ? narrowed : t;
+export type inferNaryPipe<morphs extends readonly Morph[]> = _inferNaryPipe<morphs, unknown>;
+type _inferNaryPipe<remaining extends readonly unknown[], result> = remaining extends (readonly [infer head extends Morph, ...infer tail extends Morph[]]) ? _inferNaryPipe<tail, inferMorph<result, head>> : result;
+export type inferNaryIntersection<types extends readonly unknown[]> = number extends types["length"] ? _inferNaryIntersection<unionToTuple<types[number]>, unknown> : _inferNaryIntersection<types, unknown>;
+type _inferNaryIntersection<remaining extends readonly unknown[], result> = remaining extends readonly [infer head, ...infer tail] ? _inferNaryIntersection<tail, inferIntersection<result, head>> : result;
+export type inferNaryMerge<types extends readonly unknown[]> = number extends types["length"] ? _inferUnorderedMerge<types> : _inferNaryMerge<types, {}>;
+type _inferUnorderedMerge<types extends readonly unknown[], optionalKey extends PropertyKey = optionalAtLeastOnceUnionKeyOf<types[number]>, requiredKey extends PropertyKey = Exclude<unionKeyOf<types[number]>, optionalKey>> = show<{
+    [k in requiredKey]: types[number] extends infer v ? v extends unknown ? k extends keyof v ? v[k] : never : never : never;
+} & {
+    [k in optionalKey]?: types[number] extends infer v ? v extends unknown ? k extends keyof v ? v[k] : never : never : never;
+}>;
+/** Coalesce keys that exist and are optional on one or more branches of a union */
+type optionalAtLeastOnceUnionKeyOf<t> = t extends unknown ? optionalKeyOf<t> : never;
+type _inferNaryMerge<remaining extends readonly unknown[], result> = remaining extends (readonly [infer head, ...infer tail extends readonly unknown[]]) ? _inferNaryMerge<tail, merge<result, head>> : result;
+export type inferMorphOut<morph extends Morph> = Exclude<ReturnType<morph>, ArkError | ArkErrors>;
+declare const isMorphOutKey: " isMorphOut";
+export interface Out<o = any> {
+    [isMorphOutKey]: true;
+    t: o;
+    introspectable: boolean;
+}
+export interface To<o = any> extends Out<o> {
+    introspectable: true;
+}
+export type InferredMorph<i = never, o extends Out = Out> = (In: i) => o;
+declare const defaultsToKey: " defaultsTo";
+export type Default<t = unknown, v = unknown> = {
+    [defaultsToKey]: [t, v];
+};
+export type withDefault<t, v, undistributed = t> = t extends InferredMorph ? addDefaultToMorph<t, v> : Default<Exclude<undistributed, InferredMorph>, v>;
+type addDefaultToMorph<t extends InferredMorph, v> = [
+    normalizeMorphDistribution<t>
+] extends [InferredMorph<infer i, infer o>] ? (In: Default<i, v>) => o : never;
+type normalizeMorphDistribution<t, undistributedIn = t extends InferredMorph<infer i> ? i : never, undistributedOut extends Out = t extends InferredMorph<never, infer o> ? [
+    o
+] extends [To<infer unwrappedOut>] ? To<unwrappedOut> : o : never> = (Extract<t, InferredMorph> extends anyOrNever ? never : Extract<t, InferredMorph> extends InferredMorph<infer i, infer o> ? [
+    undistributedOut
+] extends [o] ? (In: undistributedIn) => undistributedOut : [undistributedIn] extends [i] ? (In: undistributedIn) => undistributedOut : t : never) | Exclude<t, InferredMorph> extends infer _ ? _ : never;
+export type defaultFor<t = unknown> = (Primitive extends t ? Primitive : t extends Primitive ? t : never) | (() => t);
+export type termOrType<t> = t | Type<t, any>;
+export type inferIntersection<l, r> = normalizeMorphDistribution<_inferIntersection<l, r, false>>;
+export type inferMorph<t, morph extends Morph> = morph extends type.cast<infer tMorph> ? inferPipe<t, tMorph> : inferMorphOut<morph> extends infer out ? (In: distill.In<t>) => Out<out> : never;
+export type inferPipe<l, r> = normalizeMorphDistribution<_inferIntersection<l, r, true>>;
+type _inferIntersection<l, r, piped extends boolean> = [
+    l & r
+] extends [infer t extends anyOrNever] ? t : l extends InferredMorph<infer lIn, infer lOut> ? r extends InferredMorph<never, infer rOut> ? piped extends true ? (In: lIn) => rOut : never : piped extends true ? (In: lIn) => To<r> : (In: _inferIntersection<lIn, r, false>) => lOut : r extends InferredMorph<infer rIn, infer rOut> ? (In: _inferIntersection<rIn, l, false>) => rOut : [l, r] extends [object, object] ? intersectObjects<l, r, piped> extends infer result ? result : never : l & r;
+interface MorphableIntersection<piped extends boolean> extends Hkt<[unknown, unknown]> {
+    body: _inferIntersection<this[0], this[1], piped>;
+}
+type intersectObjects<l, r, piped extends boolean> = l extends array ? r extends array ? intersectArrays<l, r, MorphableIntersection<piped>> : // for an intersection with exactly one array operand like { name: string } & string[],
+l & r : r extends array ? l & r : keyof l & keyof r extends never ? show<l & r> : show<{
+    [k in keyof l]: k extends keyof r ? _inferIntersection<l[k], r[k], piped> : l[k];
+} & {
+    [k in keyof r]: k extends keyof l ? _inferIntersection<l[k], r[k], piped> : r[k];
+}>;

package/node_modules/arktype/out/attributes.js

@@ -0,0 +1,3 @@
+import { noSuggest } from "@ark/util";
+const isMorphOutKey = noSuggest("isMorphOut");
+const defaultsToKey = noSuggest("defaultsTo");

package/node_modules/arktype/out/config.d.ts

@@ -0,0 +1,35 @@
+import type { arkKind, TypeMeta } from "@ark/schema";
+import type { Ark } from "./keywords/keywords.ts";
+import { type ArkSchemaConfig } from "@ark/schema/config";
+import type { anyOrNever } from "@ark/util";
+export type KeywordConfig = {
+    [k in keyof Ark.flat as parseConfigurableFlatAlias<k, Ark.flat[k]>]?: TypeMeta.Collapsible;
+};
+type parseConfigurableFlatAlias<k extends string, v> = [
+    v
+] extends [anyOrNever] ? k : v extends {
+    [arkKind]: "generic" | "module";
+} ? never : k extends `${infer prefix}.root` ? prefix : k;
+export interface ArkConfig extends ArkSchemaConfig {
+    keywords?: KeywordConfig;
+}
+export declare const configure: <config extends ArkConfig>(config: config) => config;
+declare global {
+    export interface ArkEnv {
+        $(): Ark;
+    }
+}
+/**
+ * This mirrors the global ArkEnv namespace as a local export. We use it instead
+ * of the global internally due to a bug in twoslash that prevents `ark/docs`
+ * from building if we refer to the global directly.
+ *
+ * If, in the future, docs can build while arktype refers to `ArkEnv.$` directly,
+ * this can be removed.
+ */
+export declare namespace ArkAmbient {
+    type $ = ReturnType<ArkEnv["$"]>;
+    type meta = ArkEnv.meta;
+    type prototypes = ArkEnv.prototypes;
+}
+export {};

package/node_modules/arktype/out/config.js

@@ -0,0 +1,3 @@
+// eslint-disable-next-line @typescript-eslint/no-restricted-imports
+import { configureSchema } from "@ark/schema/config";
+export const configure = configureSchema;

package/node_modules/arktype/out/declare.d.ts

@@ -0,0 +1,35 @@
+import type { anyOrNever, array, equals, ErrorMessage, ErrorType, optionalKeyOf, requiredKeyOf, show, unset } from "@ark/util";
+import type { distill } from "./attributes.ts";
+import type { type } from "./keywords/keywords.ts";
+import type { inferDefinition, TerminalObjectDefinition, ThunkCast } from "./parser/definition.ts";
+import type { OptionalPropertyDefinition } from "./parser/property.ts";
+import type { TupleExpression } from "./parser/tupleExpressions.ts";
+import type { bindThis } from "./scope.ts";
+import type { Type } from "./type.ts";
+export type DeclarationParser<$> = <preinferred = unset, ctx extends DeclareContext = {}>() => {
+    type: <const def>(def: [preinferred] extends [unset] ? [
+        preinferred
+    ] extends [anyOrNever] ? validateDeclared<preinferred, def, $, ctx> : ErrorMessage<`declare<ExternalType>() requires a generic argument`> : validateDeclared<preinferred, def, $, ctx>) => Type<finalizePreinferred<preinferred, def, $, ctx>, $>;
+};
+type finalizePreinferred<preinferred, def, $, ctx extends DeclareContext> = ctx["side"] extends distill.Side ? ctx["side"] extends "in" ? (In: preinferred) => type.infer.Out<def, $> : (In: type.infer.In<def, $>) => preinferred : preinferred;
+export type DeclareContext = {
+    side?: "in" | "out";
+};
+export type validateDeclared<declared, def, $, ctx extends DeclareContext> = def extends type.validate<def, $> ? validateInference<def, declared, $, bindThis<def>, ctx> : type.validate<def, $>;
+type validateInference<def, declared, $, args, ctx extends DeclareContext> = def extends TerminalObjectDefinition | ThunkCast | TupleExpression ? keyof def extends never ? validateObjectInference<def, declared, $, args, ctx> : validateShallowInference<inferDefinition<def, $, args>, declared, ctx> : def extends array ? validateArrayInference<def, declared, $, args, ctx> : def extends object ? validateObjectInference<def, declared, $, args, ctx> : validateShallowInference<inferDefinition<def, $, args>, declared, ctx>;
+type validateArrayInference<def extends array, declared, $, args, ctx extends DeclareContext> = declared extends array ? {
+    [i in keyof declared]: i extends keyof def ? validateInference<def[i], declared[i], $, args, ctx> : declared[i];
+} : show<declarationMismatch<inferDefinition<def, $, args>, declared>>;
+type validateObjectInference<def extends object, declared, $, args, ctx extends DeclareContext> = show<{
+    [k in requiredKeyOf<declared>]: k extends keyof def ? validateInference<def[k], declared[k], $, args, ctx> : declared[k];
+} & {
+    [k in optionalKeyOf<declared> & string as declaredOptionalKeySuggestion<k, def>]: declaredOptionalValueSuggestion<def, k, declared, $, args, ctx>;
+}>;
+type declaredOptionalKeySuggestion<k extends string, def> = k extends keyof def ? def[k] extends OptionalPropertyDefinition ? k : `${k}?` : `${k}?`;
+type declaredOptionalValueSuggestion<def, k extends keyof declared & string, declared, $, args, ctx extends DeclareContext> = k extends keyof def ? def[k] extends OptionalPropertyDefinition ? validateInference<def[k], Required<declared>[k], $, args, ctx> : declared[k] : `${k}?` extends keyof def ? validateInference<def[`${k}?`], Required<declared>[k], $, args, ctx> : declared[k];
+type validateShallowInference<t, declared, ctx extends DeclareContext, inferred = ctx["side"] extends distill.Side ? distill<t, ctx["side"]> : t> = equals<inferred, declared> extends true ? unknown : show<declarationMismatch<inferred, declared>>;
+type declarationMismatch<inferred, declared> = ErrorType<{
+    declared: declared;
+    inferred: inferred;
+}>;
+export {};

package/node_modules/arktype/out/declare.js

@@ -0,0 +1 @@
+export {};

package/node_modules/arktype/out/fn.d.ts

@@ -0,0 +1,61 @@
+import type { BaseRoot, IntersectionNode } from "@ark/schema";
+import { Callable, type applyElementLabels, type conform, type Fn, type get } from "@ark/util";
+import type { distill } from "./attributes.ts";
+import type { type } from "./keywords/keywords.ts";
+import type { validateInnerDefinition } from "./parser/definition.ts";
+import type { inferTupleLiteral, validateTupleLiteral } from "./parser/tupleLiteral.ts";
+import type { InternalScope, Scope } from "./scope.ts";
+import type { Type } from "./type.ts";
+export type BaseFnParser<$ = {}> = <const args extends readonly unknown[], paramsT extends readonly unknown[] = inferTupleLiteral<args extends readonly [...infer params, ":", unknown] ? params : args, $, {}>, returnT = args extends readonly [...unknown[], ":", infer returnDef] ? type.infer<returnDef, $> : unknown>(...args: {
+    [i in keyof args]: conform<args[i], get<validateFnArgs<args, $>, i>>;
+}) => <internalSignature extends (...args: distill.Out<paramsT>) => distill.In<returnT>, externalSignature extends Fn = (...args: applyElementLabels<distill.In<paramsT>, Parameters<internalSignature>>) => args extends readonly [...unknown[], ":", unknown] ? distill.Out<returnT> : ReturnType<internalSignature>>(implementation: internalSignature) => TypedFn<externalSignature, $, args extends readonly [...unknown[], ":", unknown] ? Return.introspectable : {}>;
+export interface FnParser<$ = {}> extends BaseFnParser<$> {
+    /**
+     * The {@link Scope} in which definitions passed to this function will be parsed.
+     */
+    $: Scope<$>;
+    /**
+     * An alias of `fn` with no type-level validation or inference.
+     *
+     * Useful when wrapping `fn` or using it to parse a dynamic definition.
+     */
+    raw: RawFnParser;
+}
+export type RawFnParser = (...args: unknown[]) => (...args: unknown[]) => unknown;
+export declare class InternalFnParser extends Callable<(...args: unknown[]) => Fn> {
+    constructor($: InternalScope);
+}
+export declare namespace TypedFn {
+    type meta = {
+        introspectableReturn?: true;
+    };
+}
+export interface TypedFn<signature extends Fn = Fn, $ = {}, meta extends TypedFn.meta = {}> extends Callable<signature> {
+    expression: string;
+    params: signature extends Fn<infer params> ? Type<params, $> : never;
+    returns: Type<meta extends Return.introspectable ? ReturnType<signature> : unknown, $>;
+}
+export declare class InternalTypedFn extends Callable<(...args: unknown[]) => unknown> {
+    raw: Fn;
+    params: IntersectionNode;
+    returns: BaseRoot;
+    expression: string;
+    constructor(raw: Fn, params: IntersectionNode, returns: BaseRoot);
+}
+export declare namespace Return {
+    interface introspectable {
+        introspectableReturn: true;
+    }
+}
+type validateFnArgs<args, $> = args extends readonly unknown[] ? args extends readonly [...infer paramDefs, ":", infer returnDef] ? readonly [
+    ...validateFnParamDefs<paramDefs, $>,
+    ":",
+    type.validate<returnDef, $>
+] : validateFnParamDefs<args, $> : never;
+type validateFnParamDefs<paramDefs extends readonly unknown[], $> = paramDefs extends validateTupleLiteral<paramDefs, $, {}> ? paramDefs : paramDefs extends {
+    [i in keyof paramDefs]: paramDefs[i] extends "..." ? paramDefs[i] : validateInnerDefinition<paramDefs[i], $, {}>;
+} ? validateTupleLiteral<paramDefs, $, {}> : {
+    [i in keyof paramDefs]: validateInnerDefinition<paramDefs[i], $, {}>;
+};
+export declare const badFnReturnTypeMessage = "\":\" must be followed by exactly one return type e.g:\nfn(\"string\", \":\", \"number\")(s => s.length)";
+export {};

package/node_modules/arktype/out/fn.js

@@ -0,0 +1,54 @@
+import { Callable, throwParseError } from "@ark/util";
+export class InternalFnParser extends Callable {
+    constructor($) {
+        const attach = {
+            $: $,
+            raw: $.fn
+        };
+        super((...signature) => {
+            const returnOperatorIndex = signature.indexOf(":");
+            const lastParamIndex = returnOperatorIndex === -1 ?
+                signature.length - 1
+                : returnOperatorIndex - 1;
+            const paramDefs = signature.slice(0, lastParamIndex + 1);
+            const paramTuple = $.parse(paramDefs).assertHasKind("intersection");
+            let returnType = $.intrinsic.unknown;
+            if (returnOperatorIndex !== -1) {
+                if (returnOperatorIndex !== signature.length - 2)
+                    return throwParseError(badFnReturnTypeMessage);
+                returnType = $.parse(signature[returnOperatorIndex + 1]);
+            }
+            return (impl) => new InternalTypedFn(impl, paramTuple, returnType);
+        }, { attach });
+    }
+}
+export class InternalTypedFn extends Callable {
+    raw;
+    params;
+    returns;
+    expression;
+    constructor(raw, params, returns) {
+        const typedName = `typed ${raw.name}`;
+        const typed = {
+            // assign to a key with the expected name to force it to be created that way
+            [typedName]: (...args) => {
+                const validatedArgs = params.assert(args);
+                const returned = raw(...validatedArgs);
+                return returns.assert(returned);
+            }
+        }[typedName];
+        super(typed);
+        this.raw = raw;
+        this.params = params;
+        this.returns = returns;
+        let argsExpression = params.expression;
+        if (argsExpression[0] === "[" &&
+            argsExpression[argsExpression.length - 1] === "]")
+            argsExpression = argsExpression.slice(1, -1);
+        else if (argsExpression.endsWith("[]"))
+            argsExpression = `...${argsExpression}`;
+        this.expression = `(${argsExpression}) => ${returns?.expression ?? "unknown"}`;
+    }
+}
+export const badFnReturnTypeMessage = `":" must be followed by exactly one return type e.g:
+fn("string", ":", "number")(s => s.length)`;

package/node_modules/arktype/out/generic.d.ts

@@ -0,0 +1,118 @@
+import { GenericRoot, type arkKind, type BaseParseContext, type GenericAst, type GenericParamAst, type GenericParamDef, type genericParamNames, type LazyGenericBody } from "@ark/schema";
+import { type array, type Callable, type conform, type ErrorMessage, type ErrorType, type Hkt, type JsonStructure, type Scanner, type WhitespaceChar } from "@ark/util";
+import type { type } from "./keywords/keywords.ts";
+import type { inferAstRoot } from "./parser/ast/infer.ts";
+import type { validateAst } from "./parser/ast/validate.ts";
+import type { inferDefinition } from "./parser/definition.ts";
+import type { s, StaticState } from "./parser/reduce/static.ts";
+import { parseUntilFinalizer } from "./parser/string.ts";
+import type { Scope } from "./scope.ts";
+import type { Type } from "./type.ts";
+export type ParameterString<params extends string = string> = `<${params}>`;
+export type extractParams<s extends ParameterString> = s extends ParameterString<infer params> ? params : never;
+export type validateParameterString<s extends ParameterString, $> = parseGenericParams<extractParams<s>, $> extends infer e extends ErrorMessage ? e : s;
+export type validateGenericArg<arg, param extends GenericParamAst, $> = type.infer<arg, $> extends param[1] ? unknown : ErrorType<[`Invalid argument for ${param[0]}`, expected: param[1]]>;
+export type GenericInstantiator<params extends array<GenericParamAst>, def, $, args$> = params["length"] extends 1 ? {
+    <const a, r = instantiateGeneric<def, params, [a], $, args$>>(a: type.validate<a, args$> & validateGenericArg<a, params[0], args$>): r extends infer _ ? _ : never;
+} : params["length"] extends 2 ? {
+    <const a, const b, r = instantiateGeneric<def, params, [a, b], $, args$>>(...args: [
+        type.validate<a, args$> & validateGenericArg<a, params[0], args$>,
+        type.validate<b, args$> & validateGenericArg<b, params[1], args$>
+    ]): r extends infer _ ? _ : never;
+} : params["length"] extends 3 ? {
+    <const a, const b, const c, r = instantiateGeneric<def, params, [a, b, c], $, args$>>(...args: [
+        type.validate<a, args$> & validateGenericArg<a, params[0], args$>,
+        type.validate<b, args$> & validateGenericArg<b, params[1], args$>,
+        type.validate<c, args$> & validateGenericArg<c, params[2], args$>
+    ]): r extends infer _ ? _ : never;
+} : params["length"] extends 4 ? {
+    <const a, const b, const c, const d, r = instantiateGeneric<def, params, [a, b, c, d], $, args$>>(...args: [
+        type.validate<a, args$> & validateGenericArg<a, params[0], args$>,
+        type.validate<b, args$> & validateGenericArg<b, params[1], args$>,
+        type.validate<c, args$> & validateGenericArg<c, params[2], args$>,
+        type.validate<d, args$> & validateGenericArg<d, params[3], args$>
+    ]): r extends infer _ ? _ : never;
+} : params["length"] extends 5 ? {
+    <const a, const b, const c, const d, const e, r = instantiateGeneric<def, params, [a, b, c, d, e], $, args$>>(...args: [
+        type.validate<a, args$> & validateGenericArg<a, params[0], args$>,
+        type.validate<b, args$> & validateGenericArg<b, params[1], args$>,
+        type.validate<c, args$> & validateGenericArg<c, params[2], args$>,
+        type.validate<d, args$> & validateGenericArg<d, params[3], args$>,
+        type.validate<e, args$> & validateGenericArg<e, params[4], args$>
+    ]): r extends infer _ ? _ : never;
+} : params["length"] extends 6 ? {
+    <const a, const b, const c, const d, const e, const f, r = instantiateGeneric<def, params, [a, b, c, d, e, f], $, args$>>(...args: [
+        type.validate<a, args$> & validateGenericArg<a, params[0], args$>,
+        type.validate<b, args$> & validateGenericArg<b, params[1], args$>,
+        type.validate<c, args$> & validateGenericArg<c, params[2], args$>,
+        type.validate<d, args$> & validateGenericArg<d, params[3], args$>,
+        type.validate<e, args$> & validateGenericArg<e, params[4], args$>,
+        type.validate<f, args$> & validateGenericArg<f, params[5], args$>
+    ]): r extends infer _ ? _ : never;
+} : (error: ErrorMessage<`You may not define more than 6 positional generic parameters`>) => never;
+type instantiateGeneric<def, params extends array<GenericParamAst>, args, $, args$> = Type<[
+    def
+] extends [Hkt] ? Hkt.apply<def, {
+    [i in keyof args]: type.infer<args[i], args$>;
+}> : inferDefinition<def, $, bindGenericArgs<params, args$, args>>, args$>;
+type bindGenericArgs<params extends array<GenericParamAst>, $, args> = {
+    [i in keyof params & `${number}` as params[i][0]]: type.infer<args[i & keyof args], $>;
+};
+type baseGenericResolutions<params extends array<GenericParamAst>, $> = baseGenericConstraints<params> extends infer baseConstraints ? {
+    [k in keyof baseConstraints]: Type<baseConstraints[k], $>;
+} : never;
+export type baseGenericConstraints<params extends array<GenericParamAst>> = {
+    [i in keyof params & `${number}` as params[i][0]]: params[i][1];
+};
+export interface Generic<params extends array<GenericParamAst> = array<GenericParamAst>, bodyDef = unknown, $ = {}, arg$ = $> extends Callable<GenericInstantiator<params, bodyDef, $, arg$>> {
+    [arkKind]: "generic";
+    t: GenericAst<params, bodyDef, $, arg$>;
+    bodyDef: bodyDef;
+    params: {
+        [i in keyof params]: [params[i][0], Type<params[i][1], $>];
+    };
+    names: genericParamNames<params>;
+    constraints: {
+        [i in keyof params]: Type<params[i][1], $>;
+    };
+    $: Scope<$>;
+    arg$: Scope<arg$>;
+    internal: GenericRoot;
+    json: JsonStructure;
+}
+export type GenericConstructor<params extends array<GenericParamAst> = array<GenericParamAst>, bodyDef = unknown, $ = {}, arg$ = {}> = new () => Generic<params, bodyDef, $, arg$>;
+export declare const Generic: GenericConstructor;
+export type GenericDeclaration<name extends string = string, params extends ParameterString = ParameterString> = `${name}${params}`;
+export type parseValidGenericParams<def extends ParameterString, $> = conform<parseGenericParams<extractParams<def>, $>, array<GenericParamAst>>;
+export declare const emptyGenericParameterMessage = "An empty string is not a valid generic parameter name";
+export type emptyGenericParameterMessage = typeof emptyGenericParameterMessage;
+export type parseGenericParams<def extends string, $> = parseNextNameChar<Scanner.skipWhitespace<def>, "", [
+], $>;
+type ParamsTerminator = WhitespaceChar | ",";
+export declare const parseGenericParamName: (scanner: Scanner, result: GenericParamDef[], ctx: BaseParseContext) => GenericParamDef[];
+type parseName<unscanned extends string, result extends array<GenericParamAst>, $> = parseNextNameChar<Scanner.skipWhitespace<unscanned>, "", result, $>;
+type parseNextNameChar<unscanned extends string, name extends string, result extends array<GenericParamAst>, $> = unscanned extends `${infer lookahead}${infer nextUnscanned}` ? lookahead extends ParamsTerminator ? name extends "" ? ErrorMessage<emptyGenericParameterMessage> : lookahead extends "," ? parseName<nextUnscanned, [...result, [name, unknown]], $> : lookahead extends WhitespaceChar ? _parseOptionalConstraint<nextUnscanned, name, result, $> : never : parseNextNameChar<nextUnscanned, `${name}${lookahead}`, result, $> : name extends "" ? result : [...result, [name, unknown]];
+declare const extendsToken = "extends ";
+type extendsToken = typeof extendsToken;
+declare const _parseOptionalConstraint: (scanner: Scanner, name: string, result: GenericParamDef[], ctx: BaseParseContext) => GenericParamDef[];
+type _parseOptionalConstraint<unscanned extends string, name extends string, result extends array<GenericParamAst>, $> = Scanner.skipWhitespace<unscanned> extends (`${extendsToken}${infer nextUnscanned}`) ? parseUntilFinalizer<s.initialize<nextUnscanned>, $, {}> extends (infer finalArgState extends StaticState) ? validateAst<finalArgState["root"], $, {}> extends (infer e extends ErrorMessage) ? e : parseName<finalArgState["unscanned"], [
+    ...result,
+    [name, inferAstRoot<finalArgState["root"], $, {}>]
+], $> : never : parseName<Scanner.skipWhitespace<unscanned> extends `,${infer nextUnscanned}` ? nextUnscanned : unscanned, [
+    ...result,
+    [name, unknown]
+], $>;
+type genericParamDefToAst<schema extends GenericParamDef, $> = schema extends string ? [schema, unknown] : schema extends readonly [infer name, infer def] ? [name, type.infer<def, $>] : never;
+export type genericParamDefsToAst<defs extends array<GenericParamDef>, $> = [
+    ...{
+        [i in keyof defs]: genericParamDefToAst<defs[i], $>;
+    }
+];
+export type GenericParser<$ = {}> = <const paramsDef extends array<GenericParamDef>>(...params: {
+    [i in keyof paramsDef]: paramsDef[i] extends (readonly [infer name, infer def]) ? readonly [name, type.validate<def, $>] : paramsDef[i];
+}) => GenericBodyParser<genericParamDefsToAst<paramsDef, $>, $>;
+interface GenericBodyParser<params extends array<GenericParamAst>, $> {
+    <const body>(body: type.validate<body, $, baseGenericConstraints<params>>): Generic<params, body, $, $>;
+    <hkt extends Hkt.constructor>(instantiateDef: LazyGenericBody<baseGenericResolutions<params, $>>, hkt: hkt): Generic<params, InstanceType<hkt>, $, $>;
+}
+export {};

package/node_modules/arktype/out/generic.js

@@ -0,0 +1,37 @@
+import { GenericRoot } from "@ark/schema";
+import { throwParseError } from "@ark/util";
+import { RuntimeState } from "./parser/reduce/dynamic.js";
+import { terminatingChars } from "./parser/shift/tokens.js";
+import { parseUntilFinalizer } from "./parser/string.js";
+export const Generic = GenericRoot;
+export const emptyGenericParameterMessage = "An empty string is not a valid generic parameter name";
+export const parseGenericParamName = (scanner, result, ctx) => {
+    scanner.shiftUntilNonWhitespace();
+    const name = scanner.shiftUntilLookahead(terminatingChars);
+    if (name === "") {
+        // if we've reached the end of the string and have parsed at least one
+        // param, return the valid result
+        if (scanner.lookahead === "" && result.length)
+            return result;
+        return throwParseError(emptyGenericParameterMessage);
+    }
+    scanner.shiftUntilNonWhitespace();
+    return _parseOptionalConstraint(scanner, name, result, ctx);
+};
+const extendsToken = "extends ";
+const _parseOptionalConstraint = (scanner, name, result, ctx) => {
+    scanner.shiftUntilNonWhitespace();
+    if (scanner.unscanned.startsWith(extendsToken))
+        scanner.jumpForward(extendsToken.length);
+    else {
+        // if we don't have a contraining token here, return now so we can
+        // assume in the rest of the function body we do have a constraint
+        if (scanner.lookahead === ",")
+            scanner.shift();
+        result.push(name);
+        return parseGenericParamName(scanner, result, ctx);
+    }
+    const s = parseUntilFinalizer(new RuntimeState(scanner, ctx));
+    result.push([name, s.root]);
+    return parseGenericParamName(scanner, result, ctx);
+};

package/node_modules/arktype/out/index.d.ts

@@ -0,0 +1,12 @@
+export { ArkError, ArkErrors, Traversal, TraversalError, type ArkSchemaConfig, type ArkSchemaScopeConfig, type JsonSchema } from "@ark/schema";
+export { Hkt, inferred, ParseError } from "@ark/util";
+export { regex } from "arkregex";
+export type { distill, Out } from "./attributes.ts";
+export * from "./config.ts";
+export { Generic } from "./generic.ts";
+export { ark, declare, define, fn, generic, keywords, match, type, type Ark } from "./keywords/keywords.ts";
+export { Module, type BoundModule, type Submodule } from "./module.ts";
+export type { inferDefinition, validateDefinition } from "./parser/definition.ts";
+export { scope, type bindThis, type Scope } from "./scope.ts";
+export { Type } from "./type.ts";
+export type { BaseType } from "./variants/base.ts";