@blade-hq/agent-client 1.1.1 → 1.1.2

package/node_modules/@ark/schema/out/refinements/range.js

@@ -0,0 +1,103 @@
+import { isKeyOf, throwParseError } from "@ark/util";
+import { InternalPrimitiveConstraint } from "../constraint.js";
+export class BaseRange extends InternalPrimitiveConstraint {
+    boundOperandKind = operandKindsByBoundKind[this.kind];
+    compiledActual = this.boundOperandKind === "value" ? `data`
+        : this.boundOperandKind === "length" ? `data.length`
+            : `data.valueOf()`;
+    comparator = compileComparator(this.kind, this.exclusive);
+    numericLimit = this.rule.valueOf();
+    expression = `${this.comparator} ${this.rule}`;
+    compiledCondition = `${this.compiledActual} ${this.comparator} ${this.numericLimit}`;
+    compiledNegation = `${this.compiledActual} ${negatedComparators[this.comparator]} ${this.numericLimit}`;
+    // we need to compute stringLimit before errorContext, which references it
+    // transitively through description for date bounds
+    stringLimit = this.boundOperandKind === "date" ?
+        dateLimitToString(this.numericLimit)
+        : `${this.numericLimit}`;
+    limitKind = this.comparator["0"] === "<" ? "upper" : "lower";
+    isStricterThan(r) {
+        const thisLimitIsStricter = this.limitKind === "upper" ?
+            this.numericLimit < r.numericLimit
+            : this.numericLimit > r.numericLimit;
+        return (thisLimitIsStricter ||
+            (this.numericLimit === r.numericLimit &&
+                this.exclusive === true &&
+                !r.exclusive));
+    }
+    overlapsRange(r) {
+        if (this.isStricterThan(r))
+            return false;
+        if (this.numericLimit === r.numericLimit && (this.exclusive || r.exclusive))
+            return false;
+        return true;
+    }
+    overlapIsUnit(r) {
+        return (this.numericLimit === r.numericLimit && !this.exclusive && !r.exclusive);
+    }
+}
+const negatedComparators = {
+    "<": ">=",
+    "<=": ">",
+    ">": "<=",
+    ">=": "<"
+};
+export const boundKindPairsByLower = {
+    min: "max",
+    minLength: "maxLength",
+    after: "before"
+};
+export const parseExclusiveKey = {
+    // omit key with value false since it is the default
+    parse: (flag) => flag || undefined
+};
+export const createLengthSchemaNormalizer = (kind) => (schema) => {
+    if (typeof schema === "number")
+        return { rule: schema };
+    const { exclusive, ...normalized } = schema;
+    return exclusive ?
+        {
+            ...normalized,
+            rule: kind === "minLength" ? normalized.rule + 1 : normalized.rule - 1
+        }
+        : normalized;
+};
+export const createDateSchemaNormalizer = (kind) => (schema) => {
+    if (typeof schema === "number" ||
+        typeof schema === "string" ||
+        schema instanceof Date)
+        return { rule: schema };
+    const { exclusive, ...normalized } = schema;
+    if (!exclusive)
+        return normalized;
+    const numericLimit = typeof normalized.rule === "number" ? normalized.rule
+        : typeof normalized.rule === "string" ?
+            new Date(normalized.rule).valueOf()
+            : normalized.rule.valueOf();
+    return exclusive ?
+        {
+            ...normalized,
+            rule: kind === "after" ? numericLimit + 1 : numericLimit - 1
+        }
+        : normalized;
+};
+export const parseDateLimit = (limit) => typeof limit === "string" || typeof limit === "number" ?
+    new Date(limit)
+    : limit;
+export const writeInvalidLengthBoundMessage = (kind, limit) => `${kind} bound must be a positive integer (was ${limit})`;
+export const createLengthRuleParser = (kind) => (limit) => {
+    if (!Number.isInteger(limit) || limit < 0)
+        throwParseError(writeInvalidLengthBoundMessage(kind, limit));
+    return limit;
+};
+const operandKindsByBoundKind = {
+    min: "value",
+    max: "value",
+    minLength: "length",
+    maxLength: "length",
+    after: "date",
+    before: "date"
+};
+export const compileComparator = (kind, exclusive) => `${isKeyOf(kind, boundKindPairsByLower) ? ">" : "<"}${exclusive ? "" : "="}`;
+export const dateLimitToString = (limit) => typeof limit === "string" ? limit : new Date(limit).toLocaleString();
+export const writeUnboundableMessage = (root) => `Bounded expression ${root} must be exactly one of number, string, Array, or Date`;

package/node_modules/@ark/schema/out/roots/alias.d.ts

@@ -0,0 +1,45 @@
+import { type NodeId } from "../parse.ts";
+import type { NodeCompiler } from "../shared/compile.ts";
+import type { BaseNormalizedSchema, declareNode } from "../shared/declare.ts";
+import { type nodeImplementationOf } from "../shared/implement.ts";
+import type { JsonSchema } from "../shared/jsonSchema.ts";
+import type { ToJsonSchema } from "../shared/toJsonSchema.ts";
+import type { TraverseAllows, TraverseApply } from "../shared/traversal.ts";
+import { BaseRoot } from "./root.ts";
+export declare namespace Alias {
+    type Schema<alias extends string = string> = `$${alias}` | NormalizedSchema<alias>;
+    interface NormalizedSchema<alias extends string = string> extends BaseNormalizedSchema {
+        readonly reference: alias;
+        readonly resolve?: () => BaseRoot;
+    }
+    interface Inner<alias extends string = string> {
+        readonly reference: alias;
+        readonly resolve?: () => BaseRoot;
+    }
+    interface Declaration extends declareNode<{
+        kind: "alias";
+        schema: Schema;
+        normalizedSchema: NormalizedSchema;
+        inner: Inner;
+    }> {
+    }
+    type Node = AliasNode;
+}
+export declare const normalizeAliasSchema: (schema: Alias.Schema) => Alias.Inner;
+export declare class AliasNode extends BaseRoot<Alias.Declaration> {
+    readonly expression: string;
+    readonly structure: undefined;
+    get resolution(): BaseRoot;
+    protected _resolve(): BaseRoot;
+    get resolutionId(): NodeId;
+    get defaultShortDescription(): string;
+    protected innerToJsonSchema(ctx: ToJsonSchema.Context): JsonSchema;
+    traverseAllows: TraverseAllows;
+    traverseApply: TraverseApply;
+    compile(js: NodeCompiler): void;
+}
+export declare const writeShallowCycleErrorMessage: (name: string, seen: string[]) => string;
+export declare const Alias: {
+    implementation: nodeImplementationOf<Alias.Declaration>;
+    Node: typeof AliasNode;
+};

package/node_modules/@ark/schema/out/roots/alias.js

@@ -0,0 +1,115 @@
+import { append, domainDescriptions, printable, throwInternalError, throwParseError } from "@ark/util";
+import { nodesByRegisteredId } from "../parse.js";
+import { Disjoint } from "../shared/disjoint.js";
+import { implementNode } from "../shared/implement.js";
+import { intersectOrPipeNodes } from "../shared/intersections.js";
+import { $ark } from "../shared/registry.js";
+import { hasArkKind } from "../shared/utils.js";
+import { BaseRoot } from "./root.js";
+import { defineRightwardIntersections } from "./utils.js";
+export const normalizeAliasSchema = (schema) => typeof schema === "string" ? { reference: schema } : schema;
+const neverIfDisjoint = (result) => result instanceof Disjoint ? $ark.intrinsic.never.internal : result;
+const implementation = implementNode({
+    kind: "alias",
+    hasAssociatedError: false,
+    collapsibleKey: "reference",
+    keys: {
+        reference: {
+            serialize: s => (s.startsWith("$") ? s : `$ark.${s}`)
+        },
+        resolve: {}
+    },
+    normalize: normalizeAliasSchema,
+    defaults: {
+        description: node => node.reference
+    },
+    intersections: {
+        alias: (l, r, ctx) => ctx.$.lazilyResolve(() => neverIfDisjoint(intersectOrPipeNodes(l.resolution, r.resolution, ctx)), `${l.reference}${ctx.pipe ? "=>" : "&"}${r.reference}`),
+        ...defineRightwardIntersections("alias", (l, r, ctx) => {
+            if (r.isUnknown())
+                return l;
+            if (r.isNever())
+                return r;
+            if (r.isBasis() && !r.overlaps($ark.intrinsic.object)) {
+                // can be more robust as part of https://github.com/arktypeio/arktype/issues/1026
+                return Disjoint.init("assignability", $ark.intrinsic.object, r);
+            }
+            return ctx.$.lazilyResolve(() => neverIfDisjoint(intersectOrPipeNodes(l.resolution, r, ctx)), `${l.reference}${ctx.pipe ? "=>" : "&"}${r.id}`);
+        })
+    }
+});
+export class AliasNode extends BaseRoot {
+    expression = this.reference;
+    structure = undefined;
+    get resolution() {
+        const result = this._resolve();
+        return (nodesByRegisteredId[this.id] = result);
+    }
+    _resolve() {
+        if (this.resolve)
+            return this.resolve();
+        if (this.reference[0] === "$")
+            return this.$.resolveRoot(this.reference.slice(1));
+        const id = this.reference;
+        let resolution = nodesByRegisteredId[id];
+        const seen = [];
+        while (hasArkKind(resolution, "context")) {
+            if (seen.includes(resolution.id)) {
+                return throwParseError(writeShallowCycleErrorMessage(resolution.id, seen));
+            }
+            seen.push(resolution.id);
+            resolution = nodesByRegisteredId[resolution.id];
+        }
+        if (!hasArkKind(resolution, "root")) {
+            return throwInternalError(`Unexpected resolution for reference ${this.reference}
+Seen: [${seen.join("->")}] 
+Resolution: ${printable(resolution)}`);
+        }
+        return resolution;
+    }
+    get resolutionId() {
+        if (this.reference.includes("&") || this.reference.includes("=>"))
+            return this.resolution.id;
+        if (this.reference[0] !== "$")
+            return this.reference;
+        const alias = this.reference.slice(1);
+        const resolution = this.$.resolutions[alias];
+        if (typeof resolution === "string")
+            return resolution;
+        if (hasArkKind(resolution, "root"))
+            return resolution.id;
+        return throwInternalError(`Unexpected resolution for reference ${this.reference}: ${printable(resolution)}`);
+    }
+    get defaultShortDescription() {
+        return domainDescriptions.object;
+    }
+    innerToJsonSchema(ctx) {
+        return this.resolution.toJsonSchemaRecurse(ctx);
+    }
+    traverseAllows = (data, ctx) => {
+        const seen = ctx.seen[this.reference];
+        if (seen?.includes(data))
+            return true;
+        ctx.seen[this.reference] = append(seen, data);
+        return this.resolution.traverseAllows(data, ctx);
+    };
+    traverseApply = (data, ctx) => {
+        const seen = ctx.seen[this.reference];
+        if (seen?.includes(data))
+            return;
+        ctx.seen[this.reference] = append(seen, data);
+        this.resolution.traverseApply(data, ctx);
+    };
+    compile(js) {
+        const id = this.resolutionId;
+        js.if(`ctx.seen.${id} && ctx.seen.${id}.includes(data)`, () => js.return(true));
+        js.if(`!ctx.seen.${id}`, () => js.line(`ctx.seen.${id} = []`));
+        js.line(`ctx.seen.${id}.push(data)`);
+        js.return(js.invoke(id));
+    }
+}
+export const writeShallowCycleErrorMessage = (name, seen) => `Alias '${name}' has a shallow resolution cycle: ${[...seen, name].join("->")}`;
+export const Alias = {
+    implementation,
+    Node: AliasNode
+};

package/node_modules/@ark/schema/out/roots/basis.d.ts

@@ -0,0 +1,12 @@
+import type { NodeCompiler } from "../shared/compile.ts";
+import type { TraverseApply } from "../shared/traversal.ts";
+import { BaseRoot, type InternalRootDeclaration } from "./root.ts";
+export declare abstract class InternalBasis<d extends InternalRootDeclaration = InternalRootDeclaration> extends BaseRoot<d> {
+    abstract compiledCondition: string;
+    abstract compiledNegation: string;
+    structure: undefined;
+    traverseApply: TraverseApply<d["prerequisite"]>;
+    get errorContext(): d["errorContext"];
+    get compiledErrorContext(): string;
+    compile(js: NodeCompiler): void;
+}

package/node_modules/@ark/schema/out/roots/basis.js

@@ -0,0 +1,26 @@
+import { compileObjectLiteral } from "../shared/implement.js";
+import { BaseRoot } from "./root.js";
+export class InternalBasis extends BaseRoot {
+    traverseApply = (data, ctx) => {
+        if (!this.traverseAllows(data, ctx))
+            ctx.errorFromNodeContext(this.errorContext);
+    };
+    get errorContext() {
+        return {
+            code: this.kind,
+            description: this.description,
+            meta: this.meta,
+            ...this.inner
+        };
+    }
+    get compiledErrorContext() {
+        return compileObjectLiteral(this.errorContext);
+    }
+    compile(js) {
+        if (js.traversalKind === "Allows")
+            js.return(this.compiledCondition);
+        else {
+            js.if(this.compiledNegation, () => js.line(`ctx.errorFromNodeContext(${this.compiledErrorContext})`));
+        }
+    }
+}

package/node_modules/@ark/schema/out/roots/domain.d.ts

@@ -0,0 +1,45 @@
+import { type Domain as _Domain } from "@ark/util";
+import type { BaseErrorContext, BaseNormalizedSchema, declareNode } from "../shared/declare.ts";
+import { type nodeImplementationOf } from "../shared/implement.ts";
+import type { JsonSchema } from "../shared/jsonSchema.ts";
+import type { ToJsonSchema } from "../shared/toJsonSchema.ts";
+import type { TraverseAllows } from "../shared/traversal.ts";
+import { InternalBasis } from "./basis.ts";
+export type Domain = _Domain;
+export declare namespace Domain {
+    type Enumerable = "undefined" | "null" | "boolean";
+    type NonEnumerable = Exclude<Domain, Enumerable>;
+    interface Inner<domain extends NonEnumerable = NonEnumerable> {
+        readonly domain: domain;
+        readonly numberAllowsNaN?: boolean;
+    }
+    interface NormalizedSchema<domain extends NonEnumerable = NonEnumerable> extends BaseNormalizedSchema, Inner<domain> {
+    }
+    type Schema<domain extends NonEnumerable = NonEnumerable> = domain | NormalizedSchema<domain>;
+    interface ErrorContext extends BaseErrorContext<"domain">, Inner {
+    }
+    interface Declaration extends declareNode<{
+        kind: "domain";
+        schema: Schema;
+        normalizedSchema: NormalizedSchema;
+        inner: Inner;
+        errorContext: ErrorContext;
+    }> {
+    }
+    type Node = DomainNode;
+}
+export declare class DomainNode extends InternalBasis<Domain.Declaration> {
+    private readonly requiresNaNCheck;
+    readonly traverseAllows: TraverseAllows;
+    readonly compiledCondition: string;
+    readonly compiledNegation: string;
+    readonly expression: string;
+    get nestableExpression(): string;
+    get defaultShortDescription(): string;
+    protected innerToJsonSchema(ctx: ToJsonSchema.Context): JsonSchema.Constrainable;
+}
+export declare const Domain: {
+    implementation: nodeImplementationOf<Domain.Declaration>;
+    Node: typeof DomainNode;
+    writeBadAllowNanMessage: (actual: Exclude<Domain.NonEnumerable, "number">) => string;
+};

package/node_modules/@ark/schema/out/roots/domain.js

@@ -0,0 +1,72 @@
+import { domainDescriptions, domainOf, hasKey, throwParseError } from "@ark/util";
+import { Disjoint } from "../shared/disjoint.js";
+import { implementNode } from "../shared/implement.js";
+import { InternalBasis } from "./basis.js";
+const implementation = implementNode({
+    kind: "domain",
+    hasAssociatedError: true,
+    collapsibleKey: "domain",
+    keys: {
+        domain: {},
+        numberAllowsNaN: {}
+    },
+    normalize: schema => typeof schema === "string" ? { domain: schema }
+        : hasKey(schema, "numberAllowsNaN") && schema.domain !== "number" ?
+            throwParseError(Domain.writeBadAllowNanMessage(schema.domain))
+            : schema,
+    applyConfig: (schema, config) => (schema.numberAllowsNaN === undefined &&
+        schema.domain === "number" &&
+        config.numberAllowsNaN) ?
+        { ...schema, numberAllowsNaN: true }
+        : schema,
+    defaults: {
+        description: node => domainDescriptions[node.domain],
+        actual: data => Number.isNaN(data) ? "NaN" : domainDescriptions[domainOf(data)]
+    },
+    intersections: {
+        domain: (l, r) => 
+        // since l === r is handled by default, remaining cases are disjoint
+        // outside those including options like numberAllowsNaN
+        l.domain === "number" && r.domain === "number" ?
+            l.numberAllowsNaN ?
+                r
+                : l
+            : Disjoint.init("domain", l, r)
+    }
+});
+export class DomainNode extends InternalBasis {
+    requiresNaNCheck = this.domain === "number" && !this.numberAllowsNaN;
+    traverseAllows = this.requiresNaNCheck ?
+        data => typeof data === "number" && !Number.isNaN(data)
+        : data => domainOf(data) === this.domain;
+    compiledCondition = this.domain === "object" ?
+        `((typeof data === "object" && data !== null) || typeof data === "function")`
+        : `typeof data === "${this.domain}"${this.requiresNaNCheck ? " && !Number.isNaN(data)" : ""}`;
+    compiledNegation = this.domain === "object" ?
+        `((typeof data !== "object" || data === null) && typeof data !== "function")`
+        : `typeof data !== "${this.domain}"${this.requiresNaNCheck ? " || Number.isNaN(data)" : ""}`;
+    expression = this.numberAllowsNaN ? "number | NaN" : this.domain;
+    get nestableExpression() {
+        return this.numberAllowsNaN ? `(${this.expression})` : this.expression;
+    }
+    get defaultShortDescription() {
+        return domainDescriptions[this.domain];
+    }
+    innerToJsonSchema(ctx) {
+        if (this.domain === "bigint" || this.domain === "symbol") {
+            return ctx.fallback.domain({
+                code: "domain",
+                base: {},
+                domain: this.domain
+            });
+        }
+        return {
+            type: this.domain
+        };
+    }
+}
+export const Domain = {
+    implementation,
+    Node: DomainNode,
+    writeBadAllowNanMessage: (actual) => `numberAllowsNaN may only be specified with domain "number" (was ${actual})`
+};

package/node_modules/@ark/schema/out/roots/intersection.d.ts

@@ -0,0 +1,98 @@
+import { type array, type listable, type show } from "@ark/util";
+import type { nodeOfKind, NodeSchema, Prerequisite, RootSchema } from "../kinds.ts";
+import type { PredicateNode } from "../predicate.ts";
+import type { NodeCompiler } from "../shared/compile.ts";
+import type { BaseErrorContext, BaseNormalizedSchema, declareNode } from "../shared/declare.ts";
+import type { ArkError } from "../shared/errors.ts";
+import { type ConstraintKind, type nodeImplementationOf, type OpenNodeKind, type PrestructuralKind, type RefinementKind, type StructuralKind } from "../shared/implement.ts";
+import type { JsonSchema } from "../shared/jsonSchema.ts";
+import type { ToJsonSchema } from "../shared/toJsonSchema.ts";
+import type { TraverseAllows, TraverseApply } from "../shared/traversal.ts";
+import { type makeRootAndArrayPropertiesMutable } from "../shared/utils.ts";
+import type { Structure, UndeclaredKeyBehavior } from "../structure/structure.ts";
+import type { Domain } from "./domain.ts";
+import type { Morph } from "./morph.ts";
+import type { Proto } from "./proto.ts";
+import { BaseRoot } from "./root.ts";
+export declare namespace Intersection {
+    type BasisKind = "domain" | "proto";
+    type ChildKind = BasisKind | RefinementKind;
+    type FlattenedChildKind = ChildKind | StructuralKind;
+    type RefinementsInner = {
+        [k in RefinementKind]?: intersectionChildInnerValueOf<k>;
+    };
+    interface Inner extends RefinementsInner {
+        domain?: Domain.Node;
+        proto?: Proto.Node;
+        structure?: Structure.Node;
+        predicate?: array<PredicateNode>;
+    }
+    namespace Inner {
+        type mutable = makeRootAndArrayPropertiesMutable<Inner>;
+    }
+    type ConstraintsSchema<inferredBasis = any> = show<BaseNormalizedSchema & {
+        domain?: Domain.Schema;
+        proto?: Proto.Schema;
+    } & conditionalRootOf<inferredBasis>>;
+    type NormalizedSchema = Omit<ConstraintsSchema, StructuralKind | "undeclared">;
+    type Schema<inferredBasis = any> = ConstraintsSchema<inferredBasis>;
+    interface AstSchema extends BaseNormalizedSchema {
+        intersection: readonly RootSchema[];
+    }
+    interface ErrorContext extends BaseErrorContext<"intersection">, Inner {
+        errors: readonly ArkError[];
+    }
+    type Declaration = declareNode<{
+        kind: "intersection";
+        schema: Schema;
+        normalizedSchema: NormalizedSchema;
+        inner: Inner;
+        reducibleTo: "intersection" | BasisKind;
+        errorContext: ErrorContext;
+        childKind: ChildKind;
+    }>;
+    type Node = IntersectionNode;
+}
+export declare class IntersectionNode extends BaseRoot<Intersection.Declaration> {
+    basis: nodeOfKind<Intersection.BasisKind> | null;
+    prestructurals: array<nodeOfKind<PrestructuralKind>>;
+    refinements: array<nodeOfKind<RefinementKind>>;
+    structure: Structure.Node | undefined;
+    expression: string;
+    get shallowMorphs(): array<Morph>;
+    get defaultShortDescription(): string;
+    protected innerToJsonSchema(ctx: ToJsonSchema.Context): JsonSchema;
+    traverseAllows: TraverseAllows;
+    traverseApply: TraverseApply;
+    compile(js: NodeCompiler): void;
+}
+export declare const Intersection: {
+    implementation: nodeImplementationOf<{
+        intersectionIsOpen: false;
+        prerequisite: unknown;
+        kind: "intersection";
+        schema: Intersection.Schema;
+        normalizedSchema: Intersection.NormalizedSchema;
+        inner: Intersection.Inner;
+        reducibleTo: "intersection" | Intersection.BasisKind;
+        errorContext: Intersection.ErrorContext;
+        childKind: Intersection.ChildKind;
+    }>;
+    Node: typeof IntersectionNode;
+};
+export type ConditionalTerminalIntersectionRoot = {
+    undeclared?: UndeclaredKeyBehavior;
+};
+type ConditionalTerminalIntersectionKey = keyof ConditionalTerminalIntersectionRoot;
+type ConditionalIntersectionKey = ConstraintKind | ConditionalTerminalIntersectionKey;
+export type constraintKindOf<t> = {
+    [k in ConstraintKind]: t extends Prerequisite<k> ? k : never;
+}[ConstraintKind];
+type conditionalIntersectionKeyOf<t> = constraintKindOf<t> | (t extends object ? "undeclared" : never);
+type intersectionChildSchemaValueOf<k extends Intersection.FlattenedChildKind> = k extends OpenNodeKind ? listable<NodeSchema<k>> : NodeSchema<k>;
+type conditionalSchemaValueOfKey<k extends ConditionalIntersectionKey> = k extends Intersection.FlattenedChildKind ? intersectionChildSchemaValueOf<k> : ConditionalTerminalIntersectionRoot[k & ConditionalTerminalIntersectionKey];
+type intersectionChildInnerValueOf<k extends Intersection.FlattenedChildKind> = k extends OpenNodeKind ? readonly nodeOfKind<k>[] : nodeOfKind<k>;
+export type conditionalRootOf<t> = {
+    [k in conditionalIntersectionKeyOf<t>]?: conditionalSchemaValueOfKey<k>;
+};
+export {};