@blade-hq/agent-client 1.1.1 → 1.1.2

package/node_modules/@ark/schema/out/shared/declare.d.ts

@@ -0,0 +1,80 @@
+import type { merge, show } from "@ark/util";
+import type { UnknownErrorConfigs } from "../config.ts";
+import type { nodeOfKind, reducibleKindOf } from "../kinds.ts";
+import type { Disjoint } from "./disjoint.ts";
+import type { ArkErrors } from "./errors.ts";
+import type { NarrowedAttachments, NodeKind } from "./implement.ts";
+import type { JsonSchema } from "./jsonSchema.ts";
+type withMetaPrefixedKeys<o> = {
+    [k in keyof o as k extends string ? `meta.${k}` : never]: o[k];
+};
+export interface DefaultArkEnv {
+    meta(): {};
+    onFail(errors: ArkErrors): ArkErrors;
+}
+interface NodeMeta extends JsonSchema.UniversalMeta, UnknownErrorConfigs {
+    alias?: string;
+    onFail?: ArkErrors.Handler;
+}
+declare global {
+    export interface ArkEnv extends DefaultArkEnv {
+    }
+    export namespace ArkEnv {
+        type meta = show<NodeMeta & ReturnType<ArkEnv["meta"]>>;
+        type onFail = ReturnType<ArkEnv["onFail"]>;
+    }
+}
+export type TypeMeta = Omit<ArkEnv.meta, "onFail">;
+export declare namespace TypeMeta {
+    type Collapsible<meta extends TypeMeta = TypeMeta> = meta | string;
+    type Mapper<meta extends TypeMeta = TypeMeta> = (existing: Readonly<meta>) => meta;
+    type MappableInput<meta extends TypeMeta = TypeMeta> = Collapsible<meta> | Mapper<meta>;
+    namespace MappableInput {
+        type Internal = MappableInput<ArkEnv.meta>;
+    }
+}
+export interface BaseNormalizedSchema extends withMetaPrefixedKeys<TypeMeta> {
+    readonly meta?: ArkEnv.meta | string;
+}
+interface DeclarationInput {
+    kind: NodeKind;
+    schema: unknown;
+    normalizedSchema: BaseNormalizedSchema;
+    inner: object;
+    errorContext?: BaseErrorContext;
+    reducibleTo?: NodeKind;
+    intersectionIsOpen?: true;
+    prerequisite?: unknown;
+    childKind?: NodeKind;
+}
+export interface BaseErrorContext<kind extends NodeKind = NodeKind> {
+    readonly description?: string;
+    readonly code: kind;
+    readonly meta: ArkEnv.meta;
+}
+export type defaultErrorContext<d extends DeclarationInput> = show<BaseErrorContext<d["kind"]> & d["inner"]>;
+export type declareNode<d extends {
+    [k in keyof d]: k extends keyof DeclarationInput ? DeclarationInput[k] : never;
+} & DeclarationInput> = merge<{
+    intersectionIsOpen: false;
+    prerequisite: prerequisiteOf<d>;
+    childKind: never;
+    reducibleTo: d["kind"];
+    errorContext: null;
+}, d>;
+type prerequisiteOf<d extends DeclarationInput> = "prerequisite" extends keyof d ? d["prerequisite"] : unknown;
+export type attachmentsOf<d extends BaseNodeDeclaration> = NarrowedAttachments<d> & attachedInner<d>;
+type attachedInner<d extends BaseNodeDeclaration> = "intersection" & d["kind"] extends never ? d["inner"] : {};
+export interface BaseNodeDeclaration {
+    kind: NodeKind;
+    schema: unknown;
+    normalizedSchema: BaseNormalizedSchema;
+    inner: {};
+    reducibleTo: NodeKind;
+    prerequisite: any;
+    intersectionIsOpen: boolean;
+    childKind: NodeKind;
+    errorContext: BaseErrorContext | null;
+}
+export type ownIntersectionResult<d extends BaseNodeDeclaration> = nodeOfKind<reducibleKindOf<d["kind"]>> | Disjoint;
+export {};

package/node_modules/@ark/schema/out/shared/declare.js

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

package/node_modules/@ark/schema/out/shared/disjoint.d.ts

@@ -0,0 +1,41 @@
+import { type Key } from "@ark/util";
+import type { nodeOfKind } from "../kinds.ts";
+import type { BaseNode } from "../node.ts";
+import type { BoundKind } from "../refinements/kinds.ts";
+import type { Domain } from "../roots/domain.ts";
+import type { BaseRoot } from "../roots/root.ts";
+import type { Prop } from "../structure/prop.ts";
+export interface DisjointEntry<kind extends DisjointKind = DisjointKind> {
+    kind: kind;
+    l: OperandsByDisjointKind[kind];
+    r: OperandsByDisjointKind[kind];
+    path: Key[];
+    optional: boolean;
+}
+type OperandsByDisjointKind = {
+    domain: nodeOfKind<"domain"> | Domain.Enumerable;
+    unit: nodeOfKind<"unit">;
+    proto: nodeOfKind<"proto">;
+    presence: BaseRoot;
+    range: nodeOfKind<BoundKind>;
+    assignability: BaseNode;
+    union: readonly BaseRoot[];
+};
+export type DisjointEntryContext = {
+    path?: Key[];
+    optional?: true;
+};
+export declare class Disjoint extends Array<DisjointEntry> {
+    static init<kind extends DisjointKind>(kind: kind, l: OperandsByDisjointKind[kind], r: OperandsByDisjointKind[kind], ctx?: DisjointEntryContext): Disjoint;
+    add<kind extends DisjointKind>(kind: kind, l: OperandsByDisjointKind[kind], r: OperandsByDisjointKind[kind], ctx?: DisjointEntryContext): Disjoint;
+    get summary(): string;
+    describeReasons(): string;
+    throw(): never;
+    invert(): Disjoint;
+    withPrefixKey(key: PropertyKey, kind: Prop.Kind): Disjoint;
+    toNeverIfDisjoint(): BaseRoot;
+}
+export type DisjointKind = keyof OperandsByDisjointKind;
+export declare const writeUnsatisfiableExpressionError: <expression extends string>(expression: expression) => writeUnsatisfiableExpressionError<expression>;
+export type writeUnsatisfiableExpressionError<expression extends string> = `${expression} results in an unsatisfiable type`;
+export {};

package/node_modules/@ark/schema/out/shared/disjoint.js

@@ -0,0 +1,65 @@
+import { isArray, stringifyPath, throwParseError } from "@ark/util";
+import { $ark } from "./registry.js";
+import { isNode } from "./utils.js";
+export class Disjoint extends Array {
+    static init(kind, l, r, ctx) {
+        return new Disjoint({
+            kind,
+            l,
+            r,
+            path: ctx?.path ?? [],
+            optional: ctx?.optional ?? false
+        });
+    }
+    add(kind, l, r, ctx) {
+        this.push({
+            kind,
+            l,
+            r,
+            path: ctx?.path ?? [],
+            optional: ctx?.optional ?? false
+        });
+        return this;
+    }
+    get summary() {
+        return this.describeReasons();
+    }
+    describeReasons() {
+        if (this.length === 1) {
+            const { path, l, r } = this[0];
+            const pathString = stringifyPath(path);
+            return writeUnsatisfiableExpressionError(`Intersection${pathString && ` at ${pathString}`} of ${describeReasons(l, r)}`);
+        }
+        return `The following intersections result in unsatisfiable types:\n• ${this.map(({ path, l, r }) => `${path}: ${describeReasons(l, r)}`).join("\n• ")}`;
+    }
+    throw() {
+        return throwParseError(this.describeReasons());
+    }
+    invert() {
+        const result = this.map(entry => ({
+            ...entry,
+            l: entry.r,
+            r: entry.l
+        }));
+        // Workaround for Static Hermes, which doesn't preserve the Array subclass here
+        // https://github.com/arktypeio/arktype/issues/1027
+        if (!(result instanceof Disjoint))
+            return new Disjoint(...result);
+        return result;
+    }
+    withPrefixKey(key, kind) {
+        return this.map(entry => ({
+            ...entry,
+            path: [key, ...entry.path],
+            optional: entry.optional || kind === "optional"
+        }));
+    }
+    toNeverIfDisjoint() {
+        return $ark.intrinsic.never;
+    }
+}
+const describeReasons = (l, r) => `${describeReason(l)} and ${describeReason(r)}`;
+const describeReason = (value) => isNode(value) ? value.expression
+    : isArray(value) ? value.map(describeReason).join(" | ") || "never"
+        : String(value);
+export const writeUnsatisfiableExpressionError = (expression) => `${expression} results in an unsatisfiable type`;

package/node_modules/@ark/schema/out/shared/errors.d.ts

@@ -0,0 +1,145 @@
+import { CastableBase, ReadonlyArray, ReadonlyPath, type JsonArray, type JsonObject, type array, type merge, type propwiseXor, type show } from "@ark/util";
+import type { Prerequisite, errorContext } from "../kinds.ts";
+import type { NodeKind } from "./implement.ts";
+import type { StandardSchemaV1 } from "./standardSchema.ts";
+import type { Traversal } from "./traversal.ts";
+import { arkKind } from "./utils.ts";
+export type ArkErrorResult = ArkError | ArkErrors;
+export declare class ArkError<code extends ArkErrorCode = ArkErrorCode> extends CastableBase<ArkErrorContextInput<code>> {
+    readonly [arkKind] = "error";
+    path: ReadonlyPath;
+    data: Prerequisite<code>;
+    private nodeConfig;
+    protected input: ArkErrorContextInput<code>;
+    protected ctx: Traversal;
+    constructor(input: ArkErrorContextInput<code>, ctx: Traversal);
+    transform(f: (input: ArkErrorContextInput<code>) => ArkErrorContextInput): ArkError;
+    hasCode<code extends ArkErrorCode>(code: code): this is ArkError<code>;
+    get propString(): string;
+    get expected(): string;
+    get actual(): string;
+    get problem(): string;
+    get message(): string;
+    get flat(): ArkError[];
+    toJSON(): JsonObject;
+    toString(): string;
+    throw(): never;
+}
+export declare namespace ArkErrors {
+    type Handler<returns = unknown> = (errors: ArkErrors) => returns;
+}
+/**
+ * A ReadonlyArray of `ArkError`s returned by a Type on invalid input.
+ *
+ * Subsequent errors added at an existing path are merged into an
+ * ArkError intersection.
+ */
+export declare class ArkErrors extends ReadonlyArray<ArkError> implements StandardSchemaV1.FailureResult {
+    readonly [arkKind] = "errors";
+    protected ctx: Traversal;
+    constructor(ctx: Traversal);
+    /**
+     * Errors by a pathString representing their location.
+     */
+    byPath: Record<string, ArkError>;
+    /**
+     * {@link byPath} flattened so that each value is an array of ArkError instances at that path.
+     *
+     * ✅ Since "intersection" errors will be flattened to their constituent `.errors`,
+     * they will never be directly present in this representation.
+     */
+    get flatByPath(): Record<string, ArkError[]>;
+    /**
+     * {@link byPath} flattened so that each value is an array of problem strings at that path.
+     */
+    get flatProblemsByPath(): Record<string, string[]>;
+    /**
+     * All pathStrings at which errors are present mapped to the errors occuring
+     * at that path or any nested path within it.
+     */
+    byAncestorPath: Record<string, ArkError[]>;
+    count: number;
+    private mutable;
+    /**
+     * Throw a TraversalError based on these errors.
+     */
+    throw(): never;
+    /**
+     * Converts ArkErrors to TraversalError, a subclass of `Error` suitable for throwing with nice
+     * formatting.
+     */
+    toTraversalError(): TraversalError;
+    /**
+     * Append an ArkError to this array, ignoring duplicates.
+     */
+    add(error: ArkError): void;
+    transform(f: (e: ArkError) => ArkError): ArkErrors;
+    /**
+     * Add all errors from an ArkErrors instance, ignoring duplicates and
+     * prefixing their paths with that of the current Traversal.
+     */
+    merge(errors: ArkErrors): void;
+    /**
+     * @internal
+     */
+    affectsPath(path: ReadonlyPath): boolean;
+    /**
+     * A human-readable summary of all errors.
+     */
+    get summary(): string;
+    /**
+     * Alias of this ArkErrors instance for StandardSchema compatibility.
+     */
+    get issues(): this;
+    toJSON(): JsonArray;
+    toString(): string;
+    private addAncestorPaths;
+}
+export declare class TraversalError extends Error {
+    readonly name = "TraversalError";
+    arkErrors: ArkErrors;
+    constructor(errors: ArkErrors);
+}
+export interface DerivableErrorContext<code extends ArkErrorCode = ArkErrorCode> {
+    expected: string;
+    actual: string;
+    problem: string;
+    message: string;
+    data: Prerequisite<code>;
+    path: array<PropertyKey>;
+    propString: string;
+}
+export type DerivableErrorContextInput<code extends ArkErrorCode = ArkErrorCode> = Partial<DerivableErrorContext<code>> & propwiseXor<{
+    path?: array<PropertyKey>;
+}, {
+    relativePath?: array<PropertyKey>;
+    prefixPath?: array<PropertyKey>;
+}>;
+export type ArkErrorCode = {
+    [kind in NodeKind]: errorContext<kind> extends null ? never : kind;
+}[NodeKind];
+type ArkErrorContextInputsByCode = {
+    [code in ArkErrorCode]: errorContext<code> & DerivableErrorContextInput<code>;
+};
+export type ArkErrorContextInput<code extends ArkErrorCode = ArkErrorCode> = merge<ArkErrorContextInputsByCode[code], {
+    meta?: ArkEnv.meta;
+}>;
+export type NodeErrorContextInput<code extends ArkErrorCode = ArkErrorCode> = ArkErrorContextInputsByCode[code] & {
+    meta: ArkEnv.meta;
+};
+export type MessageContext<code extends ArkErrorCode = ArkErrorCode> = Omit<ArkError<code>, "message">;
+export type ProblemContext<code extends ArkErrorCode = ArkErrorCode> = Omit<MessageContext<code>, "problem">;
+export type CustomErrorInput = show<{
+    code?: undefined;
+} & DerivableErrorContextInput>;
+export type ArkErrorInput = string | ArkErrorContextInput | CustomErrorInput;
+export type ProblemConfig<code extends ArkErrorCode = ArkErrorCode> = string | ProblemWriter<code>;
+export type ProblemWriter<code extends ArkErrorCode = ArkErrorCode> = (context: ProblemContext<code>) => string;
+export type MessageConfig<code extends ArkErrorCode = ArkErrorCode> = string | MessageWriter<code>;
+export type MessageWriter<code extends ArkErrorCode = ArkErrorCode> = (context: MessageContext<code>) => string;
+export type getAssociatedDataForError<code extends ArkErrorCode> = code extends NodeKind ? Prerequisite<code> : unknown;
+export type ExpectedConfig<code extends ArkErrorCode = ArkErrorCode> = string | ExpectedWriter<code>;
+export type ExpectedWriter<code extends ArkErrorCode = ArkErrorCode> = (source: errorContext<code>) => string;
+export type ActualConfig<code extends ArkErrorCode = ArkErrorCode> = string | ActualWriter<code>;
+export type ActualWriter<code extends ArkErrorCode = ArkErrorCode> = (data: getAssociatedDataForError<code>) => string;
+export {};

package/node_modules/@ark/schema/out/shared/errors.js

@@ -0,0 +1,252 @@
+import { CastableBase, ReadonlyArray, ReadonlyPath, append, conflatenateAll, defineProperties, flatMorph, stringifyPath } from "@ark/util";
+import { arkKind } from "./utils.js";
+export class ArkError extends CastableBase {
+    [arkKind] = "error";
+    path;
+    data;
+    nodeConfig;
+    input;
+    ctx;
+    // TS gets confused by <code>, so internally we just use the base type for input
+    constructor({ prefixPath, relativePath, ...input }, ctx) {
+        super();
+        this.input = input;
+        this.ctx = ctx;
+        defineProperties(this, input);
+        const data = ctx.data;
+        if (input.code === "union") {
+            input.errors = input.errors.flatMap(innerError => {
+                // flatten union errors to avoid repeating context like "foo must be foo must be"...
+                const flat = innerError.hasCode("union") ? innerError.errors : [innerError];
+                if (!prefixPath && !relativePath)
+                    return flat;
+                return flat.map(e => e.transform(e => ({
+                    ...e,
+                    path: conflatenateAll(prefixPath, e.path, relativePath)
+                })));
+            });
+        }
+        this.nodeConfig = ctx.config[this.code];
+        const basePath = [...(input.path ?? ctx.path)];
+        if (relativePath)
+            basePath.push(...relativePath);
+        if (prefixPath)
+            basePath.unshift(...prefixPath);
+        this.path = new ReadonlyPath(...basePath);
+        this.data = "data" in input ? input.data : data;
+    }
+    transform(f) {
+        return new ArkError(f({
+            data: this.data,
+            path: this.path,
+            ...this.input
+        }), this.ctx);
+    }
+    hasCode(code) {
+        return this.code === code;
+    }
+    get propString() {
+        return stringifyPath(this.path);
+    }
+    get expected() {
+        if (this.input.expected)
+            return this.input.expected;
+        const config = this.meta?.expected ?? this.nodeConfig.expected;
+        return typeof config === "function" ? config(this.input) : config;
+    }
+    get actual() {
+        if (this.input.actual)
+            return this.input.actual;
+        const config = this.meta?.actual ?? this.nodeConfig.actual;
+        return typeof config === "function" ? config(this.data) : config;
+    }
+    get problem() {
+        if (this.input.problem)
+            return this.input.problem;
+        const config = this.meta?.problem ?? this.nodeConfig.problem;
+        return typeof config === "function" ? config(this) : config;
+    }
+    get message() {
+        if (this.input.message)
+            return this.input.message;
+        const config = this.meta?.message ?? this.nodeConfig.message;
+        return typeof config === "function" ? config(this) : config;
+    }
+    get flat() {
+        return this.hasCode("intersection") ? [...this.errors] : [this];
+    }
+    toJSON() {
+        return {
+            data: this.data,
+            path: this.path,
+            ...this.input,
+            expected: this.expected,
+            actual: this.actual,
+            problem: this.problem,
+            message: this.message
+        };
+    }
+    toString() {
+        return this.message;
+    }
+    throw() {
+        throw this;
+    }
+}
+/**
+ * A ReadonlyArray of `ArkError`s returned by a Type on invalid input.
+ *
+ * Subsequent errors added at an existing path are merged into an
+ * ArkError intersection.
+ */
+export class ArkErrors extends ReadonlyArray {
+    [arkKind] = "errors";
+    ctx;
+    constructor(ctx) {
+        super();
+        this.ctx = ctx;
+    }
+    /**
+     * Errors by a pathString representing their location.
+     */
+    byPath = Object.create(null);
+    /**
+     * {@link byPath} flattened so that each value is an array of ArkError instances at that path.
+     *
+     * ✅ Since "intersection" errors will be flattened to their constituent `.errors`,
+     * they will never be directly present in this representation.
+     */
+    get flatByPath() {
+        return flatMorph(this.byPath, (k, v) => [k, v.flat]);
+    }
+    /**
+     * {@link byPath} flattened so that each value is an array of problem strings at that path.
+     */
+    get flatProblemsByPath() {
+        return flatMorph(this.byPath, (k, v) => [k, v.flat.map(e => e.problem)]);
+    }
+    /**
+     * All pathStrings at which errors are present mapped to the errors occuring
+     * at that path or any nested path within it.
+     */
+    byAncestorPath = Object.create(null);
+    count = 0;
+    mutable = this;
+    /**
+     * Throw a TraversalError based on these errors.
+     */
+    throw() {
+        throw this.toTraversalError();
+    }
+    /**
+     * Converts ArkErrors to TraversalError, a subclass of `Error` suitable for throwing with nice
+     * formatting.
+     */
+    toTraversalError() {
+        return new TraversalError(this);
+    }
+    /**
+     * Append an ArkError to this array, ignoring duplicates.
+     */
+    add(error) {
+        const existing = this.byPath[error.propString];
+        if (existing) {
+            if (error === existing)
+                return;
+            // If the existing error is an error for a value constrained to "never",
+            // then we don't want to intersect the error messages.
+            if (existing.hasCode("union") && existing.errors.length === 0)
+                return;
+            // If the new error is an error for a value constrained to "never",
+            // then we want to override any existing errors.
+            const errorIntersection = error.hasCode("union") && error.errors.length === 0 ?
+                error
+                : new ArkError({
+                    code: "intersection",
+                    errors: existing.hasCode("intersection") ?
+                        [...existing.errors, error]
+                        : [existing, error]
+                }, this.ctx);
+            const existingIndex = this.indexOf(existing);
+            this.mutable[existingIndex === -1 ? this.length : existingIndex] =
+                errorIntersection;
+            this.byPath[error.propString] = errorIntersection;
+            // add the original error here rather than the intersection
+            // since the intersection is reflected by the array of errors at
+            // this path
+            this.addAncestorPaths(error);
+        }
+        else {
+            this.byPath[error.propString] = error;
+            this.addAncestorPaths(error);
+            this.mutable.push(error);
+        }
+        this.count++;
+    }
+    transform(f) {
+        const result = new ArkErrors(this.ctx);
+        for (const e of this)
+            result.add(f(e));
+        return result;
+    }
+    /**
+     * Add all errors from an ArkErrors instance, ignoring duplicates and
+     * prefixing their paths with that of the current Traversal.
+     */
+    merge(errors) {
+        for (const e of errors) {
+            this.add(new ArkError({ ...e, path: [...this.ctx.path, ...e.path] }, this.ctx));
+        }
+    }
+    /**
+     * @internal
+     */
+    affectsPath(path) {
+        if (this.length === 0)
+            return false;
+        return (
+        // this would occur if there is an existing error at a prefix of path
+        // e.g. the path is ["foo", "bar"] and there is an error at ["foo"]
+        path.stringifyAncestors().some(s => s in this.byPath) ||
+            // this would occur if there is an existing error at a suffix of path
+            // e.g. the path is ["foo"] and there is an error at ["foo", "bar"]
+            path.stringify() in this.byAncestorPath);
+    }
+    /**
+     * A human-readable summary of all errors.
+     */
+    get summary() {
+        return this.toString();
+    }
+    /**
+     * Alias of this ArkErrors instance for StandardSchema compatibility.
+     */
+    get issues() {
+        return this;
+    }
+    toJSON() {
+        return [...this.map(e => e.toJSON())];
+    }
+    toString() {
+        return this.join("\n");
+    }
+    addAncestorPaths(error) {
+        for (const propString of error.path.stringifyAncestors()) {
+            this.byAncestorPath[propString] = append(this.byAncestorPath[propString], error);
+        }
+    }
+}
+export class TraversalError extends Error {
+    name = "TraversalError";
+    constructor(errors) {
+        if (errors.length === 1)
+            super(errors.summary);
+        else
+            super("\n" + errors.map(error => `  • ${indent(error)}`).join("\n"));
+        Object.defineProperty(this, "arkErrors", {
+            value: errors,
+            enumerable: false
+        });
+    }
+}
+const indent = (error) => error.toString().split("\n").join("\n  ");