@blade-hq/agent-client 1.1.1 → 1.1.2

package/node_modules/arktype/out/index.js

@@ -0,0 +1,9 @@
+export { ArkError, ArkErrors, Traversal, TraversalError } from "@ark/schema";
+export { Hkt, inferred, ParseError } from "@ark/util";
+export { regex } from "arkregex";
+export * from "./config.js";
+export { Generic } from "./generic.js";
+export { ark, declare, define, fn, generic, keywords, match, type } from "./keywords/keywords.js";
+export { Module } from "./module.js";
+export { scope } from "./scope.js";
+export { Type } from "./type.js";

package/node_modules/arktype/out/keywords/Array.d.ts

@@ -0,0 +1,20 @@
+import { Hkt, liftArray, type Digit } from "@ark/util";
+import type { To } from "../attributes.ts";
+import type { Module, Submodule } from "../module.ts";
+declare class liftFromHkt extends Hkt<[element: unknown]> {
+    body: liftArray<this[0]> extends infer lifted ? (In: this[0] | lifted) => To<lifted> : never;
+}
+declare const liftFrom: import("@ark/schema").GenericRoot<readonly [["element", unknown]], liftFromHkt>;
+export declare const arkArray: arkArray.module;
+export declare namespace arkArray {
+    type module = Module<submodule>;
+    type submodule = Submodule<$>;
+    type $ = {
+        root: unknown[];
+        readonly: readonly unknown[];
+        index: NonNegativeIntegerString;
+        liftFrom: typeof liftFrom.t;
+    };
+}
+export type NonNegativeIntegerString = `${Digit}` | (`${Exclude<Digit, 0>}${string}` & `${bigint}`);
+export {};

package/node_modules/arktype/out/keywords/Array.js

@@ -0,0 +1,21 @@
+import { genericNode, intrinsic, rootSchema } from "@ark/schema";
+import { Hkt, liftArray } from "@ark/util";
+import { Scope } from "../scope.js";
+class liftFromHkt extends Hkt {
+}
+const liftFrom = genericNode("element")(args => {
+    const nonArrayElement = args.element.exclude(intrinsic.Array);
+    const lifted = nonArrayElement.array();
+    return nonArrayElement
+        .rawOr(lifted)
+        .pipe(liftArray)
+        .distribute(branch => branch.assertHasKind("morph").declareOut(lifted), rootSchema);
+}, liftFromHkt);
+export const arkArray = Scope.module({
+    root: intrinsic.Array,
+    readonly: "root",
+    index: intrinsic.nonNegativeIntegerString,
+    liftFrom
+}, {
+    name: "Array"
+});

package/node_modules/arktype/out/keywords/FormData.d.ts

@@ -0,0 +1,15 @@
+import type { To } from "../attributes.ts";
+import type { Module, Submodule } from "../module.ts";
+export type FormDataValue = string | File;
+export type ParsedFormData = Record<string, FormDataValue | FormDataValue[]>;
+export declare const arkFormData: arkFormData.module;
+export declare namespace arkFormData {
+    type module = Module<submodule>;
+    type submodule = Submodule<$>;
+    type $ = {
+        root: FormData;
+        value: FormDataValue;
+        parse: (In: FormData) => To<ParsedFormData>;
+        parsed: ParsedFormData;
+    };
+}

package/node_modules/arktype/out/keywords/FormData.js

@@ -0,0 +1,40 @@
+import { rootSchema } from "@ark/schema";
+import { registry } from "@ark/util";
+import { Scope } from "../scope.js";
+const value = rootSchema(["string", registry.FileConstructor]);
+const parsedFormDataValue = value.rawOr(value.array());
+const parsed = rootSchema({
+    meta: "an object representing parsed form data",
+    domain: "object",
+    index: {
+        signature: "string",
+        value: parsedFormDataValue
+    }
+});
+export const arkFormData = Scope.module({
+    root: ["instanceof", FormData],
+    value,
+    parsed,
+    parse: rootSchema({
+        in: FormData,
+        morphs: (data) => {
+            const result = {};
+            for (const [k, v] of data) {
+                if (k in result) {
+                    const existing = result[k];
+                    if (typeof existing === "string" ||
+                        existing instanceof registry.FileConstructor)
+                        result[k] = [existing, v];
+                    else
+                        existing.push(v);
+                }
+                else
+                    result[k] = v;
+            }
+            return result;
+        },
+        declaredOut: parsed
+    })
+}, {
+    name: "FormData"
+});

package/node_modules/arktype/out/keywords/TypedArray.d.ts

@@ -0,0 +1,19 @@
+import type { Module, Submodule } from "../module.ts";
+export declare const TypedArray: TypedArray.module;
+export declare namespace TypedArray {
+    type module = Module<TypedArray.$>;
+    type submodule = Submodule<$>;
+    type $ = {
+        Int8: Int8Array;
+        Uint8: Uint8Array;
+        Uint8Clamped: Uint8ClampedArray;
+        Int16: Int16Array;
+        Uint16: Uint16Array;
+        Int32: Int32Array;
+        Uint32: Uint32Array;
+        Float32: Float32Array;
+        Float64: Float64Array;
+        BigInt64: BigInt64Array;
+        BigUint64: BigUint64Array;
+    };
+}

package/node_modules/arktype/out/keywords/TypedArray.js

@@ -0,0 +1,16 @@
+import { Scope } from "../scope.js";
+export const TypedArray = Scope.module({
+    Int8: ["instanceof", Int8Array],
+    Uint8: ["instanceof", Uint8Array],
+    Uint8Clamped: ["instanceof", Uint8ClampedArray],
+    Int16: ["instanceof", Int16Array],
+    Uint16: ["instanceof", Uint16Array],
+    Int32: ["instanceof", Int32Array],
+    Uint32: ["instanceof", Uint32Array],
+    Float32: ["instanceof", Float32Array],
+    Float64: ["instanceof", Float64Array],
+    BigInt64: ["instanceof", BigInt64Array],
+    BigUint64: ["instanceof", BigUint64Array]
+}, {
+    name: "TypedArray"
+});

package/node_modules/arktype/out/keywords/builtins.d.ts

@@ -0,0 +1,18 @@
+import type * as util from "@ark/util";
+import { Hkt, type Key } from "@ark/util";
+import type { Module, Submodule } from "../module.ts";
+declare class MergeHkt extends Hkt<[base: object, props: object]> {
+    body: util.merge<this[0], this[1]>;
+    description: string;
+}
+declare const Merge: import("@ark/schema").GenericRoot<readonly [["base", object], ["props", object]], MergeHkt>;
+export declare const arkBuiltins: arkBuiltins;
+export type arkBuiltins = Module<arkBuiltins.$>;
+export declare namespace arkBuiltins {
+    type submodule = Submodule<$>;
+    type $ = {
+        Key: Key;
+        Merge: typeof Merge.t;
+    };
+}
+export {};

package/node_modules/arktype/out/keywords/builtins.js

@@ -0,0 +1,11 @@
+import { genericNode, intrinsic } from "@ark/schema";
+import { Hkt } from "@ark/util";
+import { Scope } from "../scope.js";
+class MergeHkt extends Hkt {
+    description = 'merge an object\'s properties onto another like `Merge(User, { isAdmin: "true" })`';
+}
+const Merge = genericNode(["base", intrinsic.object], ["props", intrinsic.object])(args => args.base.merge(args.props), MergeHkt);
+export const arkBuiltins = Scope.module({
+    Key: intrinsic.key,
+    Merge
+});

package/node_modules/arktype/out/keywords/constructors.d.ts

@@ -0,0 +1,31 @@
+import { type EcmascriptObjects, type PlatformObjects } from "@ark/util";
+import type { Module, Submodule } from "../module.ts";
+import { arkArray } from "./Array.ts";
+import { arkFormData } from "./FormData.ts";
+import { TypedArray } from "./TypedArray.ts";
+declare const omittedPrototypes: {
+    Boolean: 1;
+    Number: 1;
+    String: 1;
+};
+export declare const arkPrototypes: arkPrototypes.module;
+export declare namespace arkPrototypes {
+    type module = Module<submodule>;
+    type submodule = Submodule<$>;
+    interface keywords extends ecmascript, platform {
+    }
+    interface $ extends Omit<keywords, keyof wrapped>, wrapped {
+    }
+    interface wrapped {
+        Array: arkArray.submodule;
+        TypedArray: TypedArray.submodule;
+        FormData: arkFormData.submodule;
+    }
+    type ecmascript = Omit<EcmascriptObjects, keyof typeof omittedPrototypes>;
+    type platform = PlatformObjects;
+    interface instances extends ecmascript, platform {
+    }
+    type NonDegenerateName = keyof instances extends infer k ? k extends keyof instances ? {} extends instances[k] ? never : k : never : never;
+    type instanceOf<name extends NonDegenerateName = NonDegenerateName> = instances[name];
+}
+export {};

package/node_modules/arktype/out/keywords/constructors.js

@@ -0,0 +1,16 @@
+import { ecmascriptConstructors, flatMorph, platformConstructors } from "@ark/util";
+import { Scope } from "../scope.js";
+import { arkArray } from "./Array.js";
+import { arkFormData } from "./FormData.js";
+import { TypedArray } from "./TypedArray.js";
+const omittedPrototypes = {
+    Boolean: 1,
+    Number: 1,
+    String: 1
+};
+export const arkPrototypes = Scope.module({
+    ...flatMorph({ ...ecmascriptConstructors, ...platformConstructors }, (k, v) => (k in omittedPrototypes ? [] : [k, ["instanceof", v]])),
+    Array: arkArray,
+    TypedArray,
+    FormData: arkFormData
+});

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

@@ -0,0 +1,70 @@
+import type { ArkErrors, arkKind, flatResolutionsOf } from "@ark/schema";
+import type { Brand, inferred } from "@ark/util";
+import type { distill, InferredMorph, Out, To } from "../attributes.ts";
+import type { DeclarationParser } from "../declare.ts";
+import type { FnParser } from "../fn.ts";
+import type { GenericParser } from "../generic.ts";
+import type { MatchParser } from "../match.ts";
+import type { BoundModule, Module } from "../module.ts";
+import type { inferDefinition, validateDefinition } from "../parser/definition.ts";
+import { type bindThis, type Scope } from "../scope.ts";
+import type { DefinitionParser, SchemaParser, Type, TypeParser } from "../type.ts";
+import type { BaseType } from "../variants/base.ts";
+import type { instantiateType } from "../variants/instantiate.ts";
+import { arkBuiltins } from "./builtins.ts";
+import { arkPrototypes } from "./constructors.ts";
+import { number } from "./number.ts";
+import { string } from "./string.ts";
+import { arkTsGenerics, arkTsKeywords, object, unknown } from "./ts.ts";
+export interface Ark extends Omit<Ark.keywords, keyof Ark.wrapped>, Ark.wrapped {
+}
+export declare namespace Ark {
+    interface keywords extends arkTsKeywords.$, arkTsGenerics.$, arkPrototypes.keywords, arkBuiltins.$ {
+    }
+    interface wrapped extends arkPrototypes.wrapped {
+        string: string.submodule;
+        number: number.submodule;
+        object: object.submodule;
+        unknown: unknown.submodule;
+    }
+    type flat = flatResolutionsOf<Ark>;
+    interface typeAttachments extends arkTsKeywords.$ {
+        arrayIndex: arkPrototypes.$["Array"]["index"];
+        Key: arkBuiltins.$["Key"];
+        Record: arkTsGenerics.$["Record"];
+        Date: arkPrototypes.$["Date"];
+        Array: arkPrototypes.$["Array"]["root"];
+    }
+    interface boundTypeAttachments<$> extends Omit<BoundModule<typeAttachments, $>, arkKind> {
+    }
+}
+export declare const ark: Scope<Ark>;
+export declare const keywords: Module<Ark>;
+export declare const type: TypeParser<{}>;
+export declare namespace type {
+    interface cast<to> {
+        [inferred]?: to;
+    }
+    type errors = ArkErrors;
+    type validate<def, $ = {}, args = bindThis<def>> = validateDefinition<def, $, args>;
+    type instantiate<def, $ = {}, args = bindThis<def>> = instantiateType<inferDefinition<def, $, args>, $>;
+    type infer<def, $ = {}, args = bindThis<def>> = inferDefinition<def, $, args>;
+    namespace infer {
+        type In<def, $ = {}, args = {}> = distill.In<inferDefinition<def, $, args>>;
+        type Out<def, $ = {}, args = {}> = distill.Out<inferDefinition<def, $, args>>;
+        namespace introspectable {
+            type Out<def, $ = {}, args = {}> = distill.introspectable.Out<inferDefinition<def, $, args>>;
+        }
+    }
+    type brand<t, id> = t extends InferredMorph<infer i, infer o> ? o["introspectable"] extends true ? (In: i) => To<Brand<o["t"], id>> : (In: i) => Out<Brand<o["t"], id>> : Brand<t, id>;
+    /** @ts-ignore cast variance */
+    interface Any<out t = any, $ = any> extends BaseType<t, $> {
+    }
+}
+export type type<t = unknown, $ = {}> = Type<t, $>;
+export declare const match: MatchParser<{}>;
+export declare const fn: FnParser<{}>;
+export declare const generic: GenericParser<{}>;
+export declare const schema: SchemaParser<{}>;
+export declare const define: DefinitionParser<{}>;
+export declare const declare: DeclarationParser<{}>;

package/node_modules/arktype/out/keywords/keywords.js

@@ -0,0 +1,48 @@
+import { $arkTypeRegistry, scope } from "../scope.js";
+import { arkBuiltins } from "./builtins.js";
+import { arkPrototypes } from "./constructors.js";
+import { number } from "./number.js";
+import { string } from "./string.js";
+import { arkTsGenerics, arkTsKeywords, object, unknown } from "./ts.js";
+export const ark = scope({
+    ...arkTsKeywords,
+    ...arkTsGenerics,
+    ...arkPrototypes,
+    ...arkBuiltins,
+    string,
+    number,
+    object,
+    unknown
+}, { prereducedAliases: true, name: "ark" });
+export const keywords = ark.export();
+Object.assign($arkTypeRegistry.ambient, keywords);
+$arkTypeRegistry.typeAttachments = {
+    string: keywords.string.root,
+    number: keywords.number.root,
+    bigint: keywords.bigint,
+    boolean: keywords.boolean,
+    symbol: keywords.symbol,
+    undefined: keywords.undefined,
+    null: keywords.null,
+    object: keywords.object.root,
+    unknown: keywords.unknown.root,
+    false: keywords.false,
+    true: keywords.true,
+    never: keywords.never,
+    arrayIndex: keywords.Array.index,
+    Key: keywords.Key,
+    Record: keywords.Record,
+    Array: keywords.Array.root,
+    Date: keywords.Date
+};
+export const type = Object.assign(ark.type, 
+// assign attachments newly parsed in keywords
+// future scopes add these directly from the
+// registry when their TypeParsers are instantiated
+$arkTypeRegistry.typeAttachments);
+export const match = ark.match;
+export const fn = ark.fn;
+export const generic = ark.generic;
+export const schema = ark.schema;
+export const define = ark.define;
+export const declare = ark.declare;

package/node_modules/arktype/out/keywords/number.d.ts

@@ -0,0 +1,23 @@
+import type { Module, Submodule } from "../module.ts";
+/**
+ * As per the ECMA-262 specification:
+ * A time value supports a slightly smaller range of -8,640,000,000,000,000 to 8,640,000,000,000,000 milliseconds.
+ *
+ * @see https://262.ecma-international.org/15.0/index.html#sec-time-values-and-time-range
+ */
+export declare const epoch: import("@ark/schema").BaseRoot<import("@ark/schema").InternalRootDeclaration>;
+export declare const integer: import("@ark/schema").BaseRoot<import("@ark/schema").InternalRootDeclaration>;
+export declare const number: number.module;
+export declare namespace number {
+    type module = Module<submodule>;
+    type submodule = Submodule<$>;
+    type $ = {
+        root: number;
+        epoch: number;
+        integer: number;
+        safe: number;
+        NaN: number;
+        Infinity: number;
+        NegativeInfinity: number;
+    };
+}

package/node_modules/arktype/out/keywords/number.js

@@ -0,0 +1,49 @@
+import { intrinsic, rootSchema } from "@ark/schema";
+import { Scope } from "../scope.js";
+/**
+ * As per the ECMA-262 specification:
+ * A time value supports a slightly smaller range of -8,640,000,000,000,000 to 8,640,000,000,000,000 milliseconds.
+ *
+ * @see https://262.ecma-international.org/15.0/index.html#sec-time-values-and-time-range
+ */
+export const epoch = rootSchema({
+    domain: {
+        domain: "number",
+        meta: "a number representing a Unix timestamp"
+    },
+    divisor: {
+        rule: 1,
+        meta: `an integer representing a Unix timestamp`
+    },
+    min: {
+        rule: -8640000000000000,
+        meta: `a Unix timestamp after -8640000000000000`
+    },
+    max: {
+        rule: 8640000000000000,
+        meta: "a Unix timestamp before 8640000000000000"
+    },
+    meta: "an integer representing a safe Unix timestamp"
+});
+export const integer = rootSchema({
+    domain: "number",
+    divisor: 1
+});
+export const number = Scope.module({
+    root: intrinsic.number,
+    integer,
+    epoch,
+    safe: rootSchema({
+        domain: {
+            domain: "number",
+            numberAllowsNaN: false
+        },
+        min: Number.MIN_SAFE_INTEGER,
+        max: Number.MAX_SAFE_INTEGER
+    }),
+    NaN: ["===", Number.NaN],
+    Infinity: ["===", Number.POSITIVE_INFINITY],
+    NegativeInfinity: ["===", Number.NEGATIVE_INFINITY]
+}, {
+    name: "number"
+});