@blade-hq/agent-client 1.1.1 → 1.1.2

package/node_modules/arktype/out/parser/tupleLiteral.d.ts

@@ -0,0 +1,95 @@
+import { postfixAfterOptionalOrDefaultableMessage, type BaseParseContext, type BaseRoot, type Sequence } from "@ark/schema";
+import { type array, type conform, type ErrorMessage, type satisfy } from "@ark/util";
+import type { inferDefinition, validateInnerDefinition } from "./definition.ts";
+import { type DefaultablePropertyTuple, type isDefaultable, type OptionalPropertyDefinition } from "./property.ts";
+export declare const parseTupleLiteral: (def: array, ctx: BaseParseContext) => BaseRoot;
+export type validateTupleLiteral<def extends array, $, args> = parseSequence<def, $, args> extends infer s extends SequenceParseState ? Readonly<s["validated"]> : never;
+export type inferTupleLiteral<def extends array, $, args> = parseSequence<def, $, args> extends infer s extends SequenceParseState ? s["inferred"] : never;
+type SequencePhase = satisfy<keyof Sequence.Inner, SequencePhase.prefix | SequencePhase.optionals | SequencePhase.defaultables | SequencePhase.postfix>;
+declare namespace SequencePhase {
+    type prefix = "prefix";
+    type optionals = "optionals";
+    type defaultables = "defaultables";
+    type postfix = "postfix";
+}
+type SequenceParseState = {
+    unscanned: array;
+    inferred: array;
+    validated: array;
+    phase: SequencePhase;
+};
+type parseSequence<def extends array, $, args> = parseNextElement<{
+    unscanned: def;
+    inferred: [];
+    validated: [];
+    phase: SequencePhase.prefix;
+}, $, args>;
+type PreparsedElementKind = "required" | SequencePhase.optionals | SequencePhase.defaultables;
+type PreparsedElement = {
+    head: unknown;
+    tail: array;
+    inferred: unknown;
+    validated: unknown;
+    kind: PreparsedElementKind;
+    spread: boolean;
+};
+declare namespace PreparsedElement {
+    type from<result extends PreparsedElement> = result;
+    type required = "required";
+    type optionals = "optionals";
+    type defaultables = "defaultables";
+}
+type preparseNextState<s extends SequenceParseState, $, args> = s["unscanned"] extends readonly ["...", infer head, ...infer tail] ? preparseNextElement<head, tail, true, $, args> : s["unscanned"] extends readonly [infer head, ...infer tail] ? preparseNextElement<head, tail, false, $, args> : null;
+type preparseNextElement<head, tail extends array, spread extends boolean, $, args> = PreparsedElement.from<{
+    head: head;
+    tail: tail;
+    inferred: inferDefinition<head, $, args>;
+    validated: validateInnerDefinition<head, $, args>;
+    kind: head extends OptionalPropertyDefinition ? PreparsedElement.optionals : head extends DefaultablePropertyTuple ? PreparsedElement.defaultables : isDefaultable<head, $, args> extends true ? PreparsedElement.defaultables : PreparsedElement.required;
+    spread: spread;
+}>;
+type parseNextElement<s extends SequenceParseState, $, args> = preparseNextState<s, $, args> extends infer next extends PreparsedElement ? parseNextElement<{
+    unscanned: next["tail"];
+    inferred: nextInferred<s, next>;
+    validated: nextValidated<s, next>;
+    phase: next["kind"] extends (SequencePhase.optionals | SequencePhase.defaultables) ? next["kind"] : number extends nextInferred<s, next>["length"] ? s["phase"] : SequencePhase.prefix;
+}, $, args> : s;
+type nextInferred<s extends SequenceParseState, next extends PreparsedElement> = next["spread"] extends true ? [
+    ...s["inferred"],
+    ...conform<next["inferred"], array>
+] : next["kind"] extends SequencePhase.optionals ? [
+    ...s["inferred"],
+    next["inferred"]?
+] : [...s["inferred"], next["inferred"]];
+type nextValidated<s extends SequenceParseState, next extends PreparsedElement> = [
+    ...s["validated"],
+    ...nextValidatedSpreadOperatorIfPresent<s, next>,
+    nextValidatedElement<s, next>
+];
+type nextValidatedSpreadOperatorIfPresent<s extends SequenceParseState, next extends PreparsedElement> = next["spread"] extends true ? [
+    next["inferred"] extends infer spreadOperand extends array ? [
+        number,
+        number
+    ] extends ([
+        s["inferred"]["length"],
+        spreadOperand["length"]
+    ]) ? ErrorMessage<multipleVariadicMessage> : "..." : ErrorMessage<writeNonArraySpreadMessage<next["head"]>>
+] : [];
+type nextValidatedElement<s extends SequenceParseState, next extends PreparsedElement> = next["kind"] extends SequencePhase.optionals ? next["spread"] extends true ? ErrorMessage<spreadOptionalMessage> : s["phase"] extends SequencePhase.postfix ? ErrorMessage<optionalOrDefaultableAfterVariadicMessage> : next["validated"] : next["kind"] extends SequencePhase.defaultables ? next["spread"] extends true ? ErrorMessage<spreadDefaultableMessage> : s["phase"] extends SequencePhase.optionals ? ErrorMessage<defaultablePostOptionalMessage> : s["phase"] extends SequencePhase.postfix ? ErrorMessage<optionalOrDefaultableAfterVariadicMessage> : next["validated"] : [s["phase"], next["spread"]] extends ([
+    SequencePhase.optionals | SequencePhase.defaultables,
+    false
+]) ? ErrorMessage<postfixAfterOptionalOrDefaultableMessage> : next["validated"];
+export declare const writeNonArraySpreadMessage: <operand extends string>(operand: operand) => writeNonArraySpreadMessage<operand>;
+type writeNonArraySpreadMessage<operand> = `Spread element must be an array${operand extends string ? ` (was ${operand})` : ""}`;
+export declare const multipleVariadicMesage = "A tuple may have at most one variadic element";
+type multipleVariadicMessage = typeof multipleVariadicMesage;
+export declare const requiredPostOptionalMessage = "A required element may not follow an optional element";
+export declare const optionalOrDefaultableAfterVariadicMessage = "An optional element may not follow a variadic element";
+type optionalOrDefaultableAfterVariadicMessage = typeof optionalOrDefaultableAfterVariadicMessage;
+export declare const spreadOptionalMessage = "A spread element cannot be optional";
+type spreadOptionalMessage = typeof spreadOptionalMessage;
+export declare const spreadDefaultableMessage = "A spread element cannot have a default";
+type spreadDefaultableMessage = typeof spreadDefaultableMessage;
+export declare const defaultablePostOptionalMessage = "A defaultable element may not follow an optional element without a default";
+type defaultablePostOptionalMessage = typeof defaultablePostOptionalMessage;
+export {};

package/node_modules/arktype/out/parser/tupleLiteral.js

@@ -0,0 +1,128 @@
+import { $ark, makeRootAndArrayPropertiesMutable, postfixAfterOptionalOrDefaultableMessage } from "@ark/schema";
+import { append, isArray, isEmptyObject, throwParseError } from "@ark/util";
+import { parseProperty } from "./property.js";
+export const parseTupleLiteral = (def, ctx) => {
+    let sequences = [{}];
+    let i = 0;
+    while (i < def.length) {
+        let spread = false;
+        if (def[i] === "..." && i < def.length - 1) {
+            spread = true;
+            i++;
+        }
+        const parsedProperty = parseProperty(def[i], ctx);
+        const [valueNode, operator, possibleDefaultValue] = !isArray(parsedProperty) ? [parsedProperty] : parsedProperty;
+        i++;
+        if (spread) {
+            if (!valueNode.extends($ark.intrinsic.Array))
+                return throwParseError(writeNonArraySpreadMessage(valueNode.expression));
+            // a spread must be distributed over branches e.g.:
+            // def: [string, ...(number[] | [true, false])]
+            // nodes: [string, ...number[]] | [string, true, false]
+            sequences = sequences.flatMap(base => 
+            // since appendElement mutates base, we have to shallow-ish clone it for each branch
+            valueNode.distribute(branch => appendSpreadBranch(makeRootAndArrayPropertiesMutable(base), branch)));
+        }
+        else {
+            sequences = sequences.map(base => {
+                if (operator === "?")
+                    return appendOptionalElement(base, valueNode);
+                if (operator === "=")
+                    return appendDefaultableElement(base, valueNode, possibleDefaultValue);
+                return appendRequiredElement(base, valueNode);
+            });
+        }
+    }
+    return ctx.$.parseSchema(sequences.map(sequence => isEmptyObject(sequence) ?
+        {
+            proto: Array,
+            exactLength: 0
+        }
+        : {
+            proto: Array,
+            sequence
+        }));
+};
+const appendRequiredElement = (base, element) => {
+    if (base.defaultables || base.optionals) {
+        return throwParseError(base.variadic ?
+            // e.g. [boolean = true, ...string[], number]
+            postfixAfterOptionalOrDefaultableMessage
+            // e.g. [string?, number]
+            : requiredPostOptionalMessage);
+    }
+    if (base.variadic) {
+        // e.g. [...string[], number]
+        base.postfix = append(base.postfix, element);
+    }
+    else {
+        // e.g. [string, number]
+        base.prefix = append(base.prefix, element);
+    }
+    return base;
+};
+const appendOptionalElement = (base, element) => {
+    if (base.variadic)
+        // e.g. [...string[], number?]
+        return throwParseError(optionalOrDefaultableAfterVariadicMessage);
+    // e.g. [string, number?]
+    base.optionals = append(base.optionals, element);
+    return base;
+};
+const appendDefaultableElement = (base, element, value) => {
+    if (base.variadic)
+        // e.g. [...string[], number = 0]
+        return throwParseError(optionalOrDefaultableAfterVariadicMessage);
+    if (base.optionals)
+        // e.g. [string?, number = 0]
+        return throwParseError(defaultablePostOptionalMessage);
+    // value's assignability to element will be checked when the
+    // sequence is instantiated by @ark/schema
+    // e.g. [string, number = 0]
+    base.defaultables = append(base.defaultables, [[element, value]]);
+    return base;
+};
+const appendVariadicElement = (base, element) => {
+    // e.g. [...string[], number, ...string[]]
+    if (base.postfix)
+        throwParseError(multipleVariadicMesage);
+    if (base.variadic) {
+        if (!base.variadic.equals(element)) {
+            // e.g. [...string[], ...number[]]
+            throwParseError(multipleVariadicMesage);
+        }
+        // e.g. [...string[], ...string[]]
+        // do nothing, second spread doesn't change the type
+    }
+    else {
+        // e.g. [string, ...number[]]
+        base.variadic = element.internal;
+    }
+    return base;
+};
+const appendSpreadBranch = (base, branch) => {
+    const spread = branch.select({ method: "find", kind: "sequence" });
+    if (!spread) {
+        // the only array with no sequence reference is unknown[]
+        return appendVariadicElement(base, $ark.intrinsic.unknown);
+    }
+    if (spread.prefix)
+        for (const node of spread.prefix)
+            appendRequiredElement(base, node);
+    if (spread.optionals)
+        for (const node of spread.optionals)
+            appendOptionalElement(base, node);
+    if (spread.variadic)
+        appendVariadicElement(base, spread.variadic);
+    if (spread.postfix)
+        for (const node of spread.postfix)
+            appendRequiredElement(base, node);
+    return base;
+};
+export const writeNonArraySpreadMessage = (operand) => `Spread element must be an array (was ${operand})`;
+export const multipleVariadicMesage = "A tuple may have at most one variadic element";
+export const requiredPostOptionalMessage = "A required element may not follow an optional element";
+export const optionalOrDefaultableAfterVariadicMessage = "An optional element may not follow a variadic element";
+export const spreadOptionalMessage = "A spread element cannot be optional";
+export const spreadDefaultableMessage = "A spread element cannot have a default";
+export const defaultablePostOptionalMessage = "A defaultable element may not follow an optional element without a default";

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

@@ -0,0 +1,158 @@
+import { BaseScope, type AliasDefEntry, type ArkSchemaRegistry, type ArkSchemaScopeConfig, type BaseNode, type BaseParseContext, type BaseParseContextInput, type BaseParseOptions, type BaseRoot, type GenericAst, type GenericParamAst, type GenericParamDef, type NodeKind, type NodeSchema, type PreparsedNodeResolution, type PrivateDeclaration, type RootKind, type RootSchema, type arkKind, type exportedNameOf, type nodeOfKind, type reducibleKindOf, type toInternalScope, type writeDuplicateAliasError } from "@ark/schema";
+import { type Brand, type ErrorType, type JsonStructure, type anyOrNever, type array, type flattenListable, type noSuggest } from "@ark/util";
+import type { DeclarationParser } from "./declare.ts";
+import { InternalFnParser, type FnParser } from "./fn.ts";
+import { type GenericDeclaration, type GenericParser, type ParameterString, type baseGenericConstraints, type parseGenericParams, type parseValidGenericParams } from "./generic.ts";
+import type { Ark, type } from "./keywords/keywords.ts";
+import { InternalMatchParser, type MatchParser } from "./match.ts";
+import type { BoundModule, Module, Submodule, exportScope, instantiateExport } from "./module.ts";
+import type { NaryIntersectionParser, NaryMergeParser, NaryPipeParser, NaryUnionParser } from "./nary.ts";
+import type { DefAst, InferredAst } from "./parser/ast/infer.ts";
+import { type inferDefinition } from "./parser/definition.ts";
+import type { ParsedOptionalProperty } from "./parser/property.ts";
+import type { ParsedDefaultableProperty } from "./parser/shift/operator/default.ts";
+import { InternalTypeParser, type DefinitionParser, type EnumeratedTypeParser, type InstanceOfTypeParser, type SchemaParser, type TypeParser, type UnitTypeParser, type ValueOfTypeParser } from "./type.ts";
+/** The convenience properties attached to `scope` */
+export type ScopeParserAttachments = Omit<ScopeParser, never>;
+export interface ArkScopeConfig extends ArkSchemaScopeConfig {
+}
+export interface ScopeParser {
+    <const def>(def: scope.validate<def>, config?: ArkScopeConfig): Scope<scope.infer<def>>;
+    define: <const def>(def: scope.validate<def>) => def;
+}
+export type ModuleParser = <const def>(def: scope.validate<def>, config?: ArkScopeConfig) => scope.infer<def> extends infer $ ? Module<{
+    [k in exportedNameOf<$>]: $[k];
+}> : never;
+export type bindThis<def> = {
+    this: Def<def>;
+};
+/** nominal type for an unparsed definition used during scope bootstrapping */
+type Def<def = {}> = Brand<def, "unparsed">;
+/** sentinel indicating a scope that will be associated with a generic has not yet been parsed */
+export type UnparsedScope = "$";
+/** These are legal as values of a scope but not as definitions in other contexts */
+type PreparsedResolution = PreparsedNodeResolution;
+type bootstrapAliases<def> = {
+    [k in Exclude<keyof def, GenericDeclaration>]: def[k] extends (PreparsedResolution) ? def[k] extends {
+        t: infer g extends GenericAst;
+    } ? g : def[k] extends Module<infer $> | BoundModule<infer $, any> ? Submodule<$> : def[k] : def[k] extends (() => infer thunkReturn extends PreparsedResolution) ? thunkReturn extends {
+        t: infer g extends GenericAst;
+    } ? g : thunkReturn extends Module<infer $> | BoundModule<infer $, any> ? Submodule<$> : thunkReturn : Def<def[k]>;
+} & {
+    [k in keyof def & GenericDeclaration as extractGenericName<k>]: GenericAst<parseValidGenericParams<extractGenericParameters<k>, bootstrapAliases<def>>, def[k], UnparsedScope>;
+};
+type inferBootstrapped<$> = {
+    [name in keyof $]: $[name] extends Def<infer def> ? inferDefinition<def, $, {}> : $[name] extends {
+        t: infer g extends GenericAst;
+    } ? bindGenericToScope<g, $> : $[name];
+} & unknown;
+export type bindGenericToScope<g extends GenericAst, $> = GenericAst<g["paramsAst"], g["bodyDef"], g["$"] extends UnparsedScope ? $ : g["$"], $>;
+type extractGenericName<k> = k extends GenericDeclaration<infer name> ? name : never;
+type extractGenericParameters<k> = k extends `${string}<${infer params}>` ? ParameterString<params> : never;
+export type resolutionToAst<alias extends string, resolution> = [
+    resolution
+] extends [anyOrNever] ? InferredAst<resolution, alias> : resolution extends Def<infer def> ? DefAst<def, alias> : resolution extends {
+    [arkKind]: "module";
+    root: infer root;
+} ? InferredAst<root, alias> : resolution extends GenericAst ? resolution : InferredAst<resolution, alias>;
+export type moduleKeyOf<$> = {
+    [k in keyof $]: $[k] extends {
+        [arkKind]: "module";
+    } ? [
+        $[k]
+    ] extends [anyOrNever] ? never : k & string : never;
+}[keyof $];
+export interface ArkTypeRegistry extends ArkSchemaRegistry {
+    typeAttachments?: Ark.boundTypeAttachments<any>;
+    ambient: exportScope<Ark>;
+}
+export declare const $arkTypeRegistry: ArkTypeRegistry;
+export interface InternalScope {
+    constructor: typeof InternalScope;
+}
+export declare class InternalScope<$ extends {} = {}> extends BaseScope<$> {
+    get ambientAttachments(): Ark.boundTypeAttachments<$> | undefined;
+    protected preparseOwnAliasEntry(alias: string, def: unknown): AliasDefEntry;
+    parseGenericParams(def: string, opts: BaseParseOptions): array<GenericParamDef>;
+    protected normalizeRootScopeValue(resolution: unknown): unknown;
+    protected preparseOwnDefinitionFormat(def: unknown, opts: BaseParseOptions): BaseRoot | BaseParseContextInput;
+    parseOwnDefinitionFormat(def: unknown, ctx: BaseParseContext): BaseRoot;
+    unit: UnitTypeParser<$>;
+    valueOf: ValueOfTypeParser<$>;
+    enumerated: EnumeratedTypeParser<$>;
+    instanceOf: InstanceOfTypeParser<$>;
+    or: NaryUnionParser<$>;
+    and: NaryIntersectionParser<$>;
+    merge: NaryMergeParser<$>;
+    pipe: NaryPipeParser<$>;
+    fn: InternalFnParser;
+    match: InternalMatchParser;
+    declare: () => {
+        type: InternalTypeParser;
+    };
+    define<def>(def: def): def;
+    type: InternalTypeParser;
+    static scope: ScopeParser;
+    static module: ModuleParser;
+}
+export declare const scope: ScopeParser;
+export declare namespace scope {
+    type validate<def> = {
+        [k in keyof def]: k extends noSuggest ? unknown : parseScopeKey<k, def>["params"] extends infer params ? params extends array<GenericParamAst> ? params["length"] extends 0 ? def[k] extends type.Any | PreparsedResolution ? def[k] : k extends (PrivateDeclaration<infer name extends keyof def & string>) ? ErrorType<writeDuplicateAliasError<name>> : type.validate<def[k], bootstrapAliases<def>, {}> : type.validate<def[k], bootstrapAliases<def>, baseGenericConstraints<params>> : params : never;
+    };
+    type infer<def> = inferBootstrapped<bootstrapAliases<def>>;
+}
+export interface Scope<$ = {}> {
+    t: $;
+    [arkKind]: "scope";
+    config: ArkScopeConfig;
+    references: readonly BaseNode[];
+    json: JsonStructure;
+    exportedNames: array<exportedNameOf<$>>;
+    /** The set of names defined at the root-level of the scope mapped to their
+     * corresponding definitions.**/
+    aliases: Record<string, unknown>;
+    internal: toInternalScope<$>;
+    defineSchema<const def extends RootSchema>(schema: def): def;
+    node<kinds extends NodeKind | array<RootKind>>(kinds: kinds, schema: NodeSchema<flattenListable<kinds>>, opts?: BaseParseOptions): nodeOfKind<reducibleKindOf<flattenListable<kinds>>>;
+    unit: UnitTypeParser<$>;
+    enumerated: EnumeratedTypeParser<$>;
+    valueOf: ValueOfTypeParser<$>;
+    instanceOf: InstanceOfTypeParser<$>;
+    type: TypeParser<$>;
+    match: MatchParser<$>;
+    fn: FnParser<$>;
+    declare: DeclarationParser<$>;
+    define: DefinitionParser<$>;
+    generic: GenericParser<$>;
+    schema: SchemaParser<$>;
+    import(): Module<{
+        [k in exportedNameOf<$> as PrivateDeclaration<k>]: $[k];
+    }>;
+    import<names extends exportedNameOf<$>[]>(...names: names): BoundModule<{
+        [k in names[number] as PrivateDeclaration<k>]: $[k];
+    } & unknown, $>;
+    export(): Module<{
+        [k in exportedNameOf<$>]: $[k];
+    }>;
+    export<names extends exportedNameOf<$>[]>(...names: names): BoundModule<{
+        [k in names[number]]: $[k];
+    } & unknown, $>;
+    resolve<name extends exportedNameOf<$>>(name: name): instantiateExport<$[name], $>;
+}
+export interface ScopeConstructor {
+    new <$ = {}>(...args: ConstructorParameters<typeof InternalScope>): Scope<$>;
+    scope: ScopeParser;
+    module: ModuleParser;
+}
+export declare const Scope: ScopeConstructor;
+export type parseScopeKey<k, def> = k extends `${infer name}<${infer params}>` ? parseGenericScopeKey<name, params, def> : {
+    name: k;
+    params: [];
+};
+type parseGenericScopeKey<name extends string, params extends string, def> = {
+    name: name;
+    params: parseGenericParams<params, bootstrapAliases<def>>;
+};
+export type InnerParseResult = BaseRoot | ParsedOptionalProperty | ParsedDefaultableProperty;
+export {};

package/node_modules/arktype/out/scope.js

@@ -0,0 +1,106 @@
+import { $ark, BaseScope, hasArkKind, parseGeneric } from "@ark/schema";
+import { Scanner, enumValues, flatMorph, isArray, isThunk, throwParseError } from "@ark/util";
+import { InternalFnParser } from "./fn.js";
+import { parseGenericParamName } from "./generic.js";
+import { InternalMatchParser } from "./match.js";
+import { shallowDefaultableMessage, shallowOptionalMessage } from "./parser/ast/validate.js";
+import { parseInnerDefinition } from "./parser/definition.js";
+import { InternalTypeParser } from "./type.js";
+export const $arkTypeRegistry = $ark;
+export class InternalScope extends BaseScope {
+    get ambientAttachments() {
+        if (!$arkTypeRegistry.typeAttachments)
+            return;
+        return this.cacheGetter("ambientAttachments", flatMorph($arkTypeRegistry.typeAttachments, (k, v) => [
+            k,
+            this.bindReference(v)
+        ]));
+    }
+    preparseOwnAliasEntry(alias, def) {
+        const firstParamIndex = alias.indexOf("<");
+        if (firstParamIndex === -1) {
+            if (hasArkKind(def, "module") || hasArkKind(def, "generic"))
+                return [alias, def];
+            const qualifiedName = this.name === "ark" ? alias
+                : alias === "root" ? this.name
+                    : `${this.name}.${alias}`;
+            const config = this.resolvedConfig.keywords?.[qualifiedName];
+            if (config)
+                def = [def, "@", config];
+            return [alias, def];
+        }
+        if (alias[alias.length - 1] !== ">") {
+            throwParseError(`'>' must be the last character of a generic declaration in a scope`);
+        }
+        const name = alias.slice(0, firstParamIndex);
+        const paramString = alias.slice(firstParamIndex + 1, -1);
+        return [
+            name,
+            // use a thunk definition for the generic so that we can parse
+            // constraints within the current scope
+            () => {
+                const params = this.parseGenericParams(paramString, { alias: name });
+                const generic = parseGeneric(params, def, this);
+                return generic;
+            }
+        ];
+    }
+    parseGenericParams(def, opts) {
+        return parseGenericParamName(new Scanner(def), [], this.createParseContext({
+            ...opts,
+            def,
+            prefix: "generic"
+        }));
+    }
+    normalizeRootScopeValue(resolution) {
+        if (isThunk(resolution) && !hasArkKind(resolution, "generic"))
+            return resolution();
+        return resolution;
+    }
+    preparseOwnDefinitionFormat(def, opts) {
+        return {
+            ...opts,
+            def,
+            prefix: opts.alias ?? "type"
+        };
+    }
+    parseOwnDefinitionFormat(def, ctx) {
+        const isScopeAlias = ctx.alias && ctx.alias in this.aliases;
+        // if the definition being parsed is not a scope alias and is not a
+        // generic instantiation (i.e. opts don't include args), add `this` as a resolution.
+        // if we're parsing a nested string, ctx.args will have already been set
+        if (!isScopeAlias && !ctx.args)
+            ctx.args = { this: ctx.id };
+        const result = parseInnerDefinition(def, ctx);
+        if (isArray(result)) {
+            if (result[1] === "=")
+                return throwParseError(shallowDefaultableMessage);
+            if (result[1] === "?")
+                return throwParseError(shallowOptionalMessage);
+        }
+        return result;
+    }
+    unit = value => this.units([value]);
+    valueOf = tsEnum => this.units(enumValues(tsEnum));
+    enumerated = (...values) => this.units(values);
+    instanceOf = ctor => this.node("proto", { proto: ctor }, { prereduced: true });
+    or = (...defs) => this.schema(defs.map(def => this.parse(def)));
+    and = (...defs) => defs.reduce((node, def) => node.and(this.parse(def)), this.intrinsic.unknown);
+    merge = (...defs) => defs.reduce((node, def) => node.merge(this.parse(def)), this.intrinsic.object);
+    pipe = (...morphs) => this.intrinsic.unknown.pipe(...morphs);
+    fn = new InternalFnParser(this);
+    match = new InternalMatchParser(this);
+    declare = () => ({
+        type: this.type
+    });
+    define(def) {
+        return def;
+    }
+    type = new InternalTypeParser(this);
+    static scope = ((def, config = {}) => new InternalScope(def, config));
+    static module = ((def, config = {}) => this.scope(def, config).export());
+}
+export const scope = Object.assign(InternalScope.scope, {
+    define: (def) => def
+});
+export const Scope = InternalScope;

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

@@ -0,0 +1,144 @@
+import { ArkErrors, BaseRoot, type BaseParseOptions, type Morph, type NodeSelector, type Predicate, type RootSchema, type TypeMeta } from "@ark/schema";
+import { Callable, Hkt, type Constructor, type array, type conform } from "@ark/util";
+import type { distill } from "./attributes.ts";
+import type { DeclarationParser } from "./declare.ts";
+import type { FnParser } from "./fn.ts";
+import type { Generic, GenericParser, ParameterString, baseGenericConstraints, parseValidGenericParams, validateParameterString } from "./generic.ts";
+import type { Ark, keywords, type } from "./keywords/keywords.ts";
+import type { MatchParser } from "./match.ts";
+import type { NaryIntersectionParser, NaryMergeParser, NaryPipeParser, NaryUnionParser } from "./nary.ts";
+import type { ArgTwoOperator, IndexZeroOperator, TupleInfixOperator } from "./parser/tupleExpressions.ts";
+import type { InternalScope, ModuleParser, Scope, ScopeParser } from "./scope.ts";
+import type { BaseType } from "./variants/base.ts";
+import type { instantiateType } from "./variants/instantiate.ts";
+/** The convenience properties attached to `type` */
+export type TypeParserAttachments = Omit<TypeParser, never>;
+export interface TypeParser<$ = {}> extends Ark.boundTypeAttachments<$> {
+    /**
+     * Create a {@link Type} from your definition.
+     *
+     * @example const Person = type({ name: "string" })
+     */
+    <const def, r = type.instantiate<def, $>>(def: type.validate<def, $>): r extends infer _ ? _ : never;
+    /**
+     * Create a {@link Generic} from a parameter string and body definition.
+     *
+     * @param params A string like "<t, n extends number>" specifying the
+     * {@link Generic}'s parameters and any associated constraints via `extends`.
+     *
+     * @param def The definition for the body of the {@link Generic}. Can reference the
+     * parameter names specified in the previous argument in addition to aliases
+     * from its {@link Scope}.
+     *
+     * @example const BoxOf = type("<t extends string | number>", { contents: "t" })
+     */
+    <const params extends ParameterString, const def, r = Generic<parseValidGenericParams<params, $>, def, $>>(params: validateParameterString<params, $>, def: type.validate<def, $, baseGenericConstraints<parseValidGenericParams<params, $>>>): r extends infer _ ? _ : never;
+    /**
+     * Create a {@link Type} from a [tuple expression](http://localhost:3000/docs/expressions)
+     * spread as this function's arguments.
+     *
+     * @example type("string", "|", { foo: "number" })
+     */
+    <const zero, const one, const rest extends array, r = type.instantiate<[zero, one, ...rest], $>>(_0: zero extends IndexZeroOperator ? zero : type.validate<zero, $>, _1: zero extends "keyof" ? type.validate<one, $> : zero extends "instanceof" ? conform<one, Constructor> : zero extends "===" ? conform<one, unknown> : conform<one, ArgTwoOperator>, ..._2: zero extends "===" ? rest : zero extends "instanceof" ? conform<rest, readonly Constructor[]> : one extends TupleInfixOperator ? one extends ":" ? [Predicate<distill.In<type.infer<zero, $>>>] : one extends "=>" ? [Morph<distill.Out<type.infer<zero, $>>, unknown>] : one extends "|>" ? [type.validate<rest[0], $>] : one extends "@" ? [TypeMeta.MappableInput, NodeSelector?] : [type.validate<rest[0], $>] : []): r extends infer _ ? _ : never;
+    /**
+     * An alias of the {@link ArkErrors} class, an instance of which is returned when a {@link Type}
+     * is invoked with invalid input.
+     *
+     * @example
+     * const out = myType(data)
+     *
+     * if(out instanceof type.errors) console.log(out.summary)
+     */
+    errors: typeof ArkErrors;
+    hkt: typeof Hkt;
+    keywords: typeof keywords;
+    /**
+     * The {@link Scope} in which definitions passed to this function will be parsed.
+     */
+    $: Scope<$>;
+    /**
+     * An alias of `type` with no type-level validation or inference.
+     *
+     * Useful when wrapping `type` or using it to parse a dynamic definition.
+     */
+    raw(def: unknown): BaseType<any, $>;
+    module: ModuleParser;
+    scope: ScopeParser;
+    define: DefinitionParser<$>;
+    declare: DeclarationParser<$>;
+    generic: GenericParser<$>;
+    match: MatchParser<$>;
+    schema: SchemaParser<$>;
+    /**
+     * Create a {@link Type} that is satisfied only by a value strictly equal (`===`) to the argument passed to this function.
+     * @example const foo = type.unit('foo') // {@link Type}<'foo'>
+     * @example const sym: unique symbol = Symbol(); type.unit(sym) // {@link Type}<typeof sym>
+     */
+    unit: UnitTypeParser<$>;
+    /**
+     * Create a {@link Type} that is satisfied only by a value strictly equal (`===`) to one of the arguments passed to this function.
+     * @example const enum = type.enumerated('foo', 'bar', obj) // obj is a by-reference object
+     * @example const TupleForm = type(['===', 'foo', 'bar', obj])
+     * @example const ArgsForm = type('===', 'foo', 'bar', obj)
+     */
+    enumerated: EnumeratedTypeParser<$>;
+    /**
+     * Create a {@link Type} that is satisfied only by one of the Object.values() of the argument passed to this function.
+     *
+     * ⚠️ For TypeScript enum compatibility, values at numeric keys with corresponding numeric values will not be included.
+     * @example const myEnum = type.valueOf(myTsEnum)
+     */
+    valueOf: ValueOfTypeParser<$>;
+    /**
+     * Create a {@link Type} that is satisfied only by a value of a specific class.
+     * @example const array = type.instanceOf(Array)
+     */
+    instanceOf: InstanceOfTypeParser<$>;
+    /**
+     * Create a {@link Type} from a union of definitions
+     * @example const T = type.or("string", "number")
+     */
+    or: NaryUnionParser<$>;
+    /**
+     * Create a {@link Type} from an intersection of definitions
+     * @example const T = type.and({ a: "1" }, { b: "2" })
+     */
+    and: NaryIntersectionParser<$>;
+    /**
+     * Create a {@link Type} by merging object definitions, with later
+     * definitions having precedence for overlapping keys
+     * @example
+     * // Type<{ a: "3", b: "2", c: "4" }>
+     * const T = type.merge({ a: "1", b: "2" }, { a: "3", c: "4" })
+     */
+    merge: NaryMergeParser<$>;
+    /**
+     * Create a {@link Type} from a set of morphs (including Types)
+     * @example
+     * // Type<(In: string) => To<object>>
+     * const T = type.pipe(type.string, s => JSON.parse(s), type.object)
+     */
+    pipe: NaryPipeParser<$>;
+    /**
+     * Define a validated function
+     * @example
+     * const len = type.fn("string | unknown[]", ":", "number")(s => s.length)
+     * len("foo") // 3
+     * // TypeScript: boolean is not assignable to string | unknown[]
+     * // Runtime (throws): must be a string or an object (was boolean)
+     * len(true)
+     */
+    fn: FnParser<$>;
+}
+export declare class InternalTypeParser extends Callable<(...args: unknown[]) => BaseRoot | Generic, TypeParserAttachments> {
+    constructor($: InternalScope);
+}
+export type UnitTypeParser<$> = <const t>(value: t) => Type<t, $>;
+export type InstanceOfTypeParser<$> = <const t extends object>(ctor: Constructor<t>) => Type<t, $>;
+export type EnumeratedTypeParser<$> = <const values extends readonly unknown[]>(...values: values) => Type<values[number], $>;
+export type ValueOfTypeParser<$> = <const o extends object>(o: o) => Type<o[keyof o], $>;
+export type DefinitionParser<$> = <const def>(def: type.validate<def, $>) => def;
+export type SchemaParser<$> = (schema: RootSchema, opts?: BaseParseOptions) => Type<unknown, $>;
+export type Type<t = unknown, $ = {}> = instantiateType<t, $>;
+export type TypeConstructor<t = unknown, $ = {}> = new (def: unknown, $: Scope<$>) => Type<t, $>;
+export declare const Type: TypeConstructor;