@blade-hq/agent-client 1.1.1 → 1.1.2

package/node_modules/@ark/schema/out/intrinsic.js

@@ -0,0 +1,56 @@
+import { node, schemaScope } from "./scope.js";
+import { $ark } from "./shared/registry.js";
+import { arrayIndexSource } from "./structure/shared.js";
+const intrinsicBases = schemaScope({
+    bigint: "bigint",
+    // since we know this won't be reduced, it can be safely cast to a union
+    boolean: [{ unit: false }, { unit: true }],
+    false: { unit: false },
+    never: [],
+    null: { unit: null },
+    number: "number",
+    object: "object",
+    string: "string",
+    symbol: "symbol",
+    true: { unit: true },
+    unknown: {},
+    undefined: { unit: undefined },
+    Array,
+    Date
+}, { prereducedAliases: true }).export();
+$ark.intrinsic = { ...intrinsicBases };
+const intrinsicRoots = schemaScope({
+    integer: {
+        domain: "number",
+        divisor: 1
+    },
+    lengthBoundable: ["string", Array],
+    key: ["string", "symbol"],
+    nonNegativeIntegerString: { domain: "string", pattern: arrayIndexSource }
+}, { prereducedAliases: true }).export();
+// needed to parse index signatures for JSON
+Object.assign($ark.intrinsic, intrinsicRoots);
+const intrinsicJson = schemaScope({
+    jsonPrimitive: [
+        "string",
+        "number",
+        { unit: true },
+        { unit: false },
+        { unit: null }
+    ],
+    jsonObject: {
+        domain: "object",
+        index: {
+            signature: "string",
+            value: "$jsonData"
+        }
+    },
+    jsonData: ["$jsonPrimitive", "$jsonObject"]
+}, { prereducedAliases: true }).export();
+export const intrinsic = {
+    ...intrinsicBases,
+    ...intrinsicRoots,
+    ...intrinsicJson,
+    emptyStructure: node("structure", {}, { prereduced: true })
+};
+$ark.intrinsic = { ...intrinsic };

package/node_modules/@ark/schema/out/kinds.d.ts

@@ -0,0 +1,73 @@
+import { type array, type listable } from "@ark/util";
+import type { BaseNode } from "./node.ts";
+import { Predicate } from "./predicate.ts";
+import { Divisor } from "./refinements/divisor.ts";
+import { type BoundDeclarations, type BoundNodesByKind } from "./refinements/kinds.ts";
+import { Pattern } from "./refinements/pattern.ts";
+import { Alias } from "./roots/alias.ts";
+import { Domain } from "./roots/domain.ts";
+import { Intersection } from "./roots/intersection.ts";
+import { Morph } from "./roots/morph.ts";
+import { Proto } from "./roots/proto.ts";
+import { Union } from "./roots/union.ts";
+import { Unit } from "./roots/unit.ts";
+import type { BaseScope } from "./scope.ts";
+import type { ConstraintKind, NodeKind, OpenNodeKind, RootKind, UnknownAttachments, UnknownNodeImplementation } from "./shared/implement.ts";
+import type { makeRootAndArrayPropertiesMutable } from "./shared/utils.ts";
+import { Index } from "./structure/index.ts";
+import { Optional } from "./structure/optional.ts";
+import { Required } from "./structure/required.ts";
+import { Sequence } from "./structure/sequence.ts";
+import { Structure } from "./structure/structure.ts";
+export interface NodeDeclarationsByKind extends BoundDeclarations {
+    alias: Alias.Declaration;
+    domain: Domain.Declaration;
+    unit: Unit.Declaration;
+    proto: Proto.Declaration;
+    union: Union.Declaration;
+    morph: Morph.Declaration;
+    intersection: Intersection.Declaration;
+    sequence: Sequence.Declaration;
+    divisor: Divisor.Declaration;
+    required: Required.Declaration;
+    optional: Optional.Declaration;
+    index: Index.Declaration;
+    pattern: Pattern.Declaration;
+    predicate: Predicate.Declaration;
+    structure: Structure.Declaration;
+}
+export declare const nodeImplementationsByKind: Record<NodeKind, UnknownNodeImplementation>;
+export declare const nodeClassesByKind: Record<NodeKind, new (attachments: UnknownAttachments, $: BaseScope) => BaseNode>;
+interface NodesByKind extends BoundNodesByKind {
+    alias: Alias.Node;
+    union: Union.Node;
+    morph: Morph.Node;
+    intersection: Intersection.Node;
+    unit: Unit.Node;
+    proto: Proto.Node;
+    domain: Domain.Node;
+    divisor: Divisor.Node;
+    pattern: Pattern.Node;
+    predicate: Predicate.Node;
+    required: Required.Node;
+    optional: Optional.Node;
+    index: Index.Node;
+    sequence: Sequence.Node;
+    structure: Structure.Node;
+}
+export type nodeOfKind<kind extends NodeKind> = NodesByKind[kind];
+export type Declaration<kind extends NodeKind> = NodeDeclarationsByKind[kind];
+export type NodeSchema<kind extends NodeKind> = Declaration<kind>["schema"];
+export type RootSchema<kind extends RootKind = RootKind> = NodeSchema<kind>;
+export type NormalizedSchema<kind extends NodeKind> = Declaration<kind>["normalizedSchema"];
+export type childKindOf<kind extends NodeKind> = Declaration<kind>["childKind"];
+export type Prerequisite<kind extends NodeKind> = Declaration<kind>["prerequisite"];
+export type reducibleKindOf<kind extends NodeKind> = Declaration<kind>["reducibleTo"] extends NodeKind ? Declaration<kind>["reducibleTo"] : kind;
+export type Inner<kind extends NodeKind> = Declaration<kind>["inner"];
+export type defAttachedAs<kind extends ConstraintKind> = kind extends OpenNodeKind ? listable<NodeSchema<kind>> : NodeSchema<kind>;
+export type innerAttachedAs<kind extends ConstraintKind> = kind extends OpenNodeKind ? array<nodeOfKind<kind>> : nodeOfKind<kind>;
+/** make nested arrays mutable while keeping nested nodes immutable */
+export type mutableInnerOfKind<kind extends NodeKind> = makeRootAndArrayPropertiesMutable<Inner<kind>>;
+export type mutableNormalizedRootOfKind<kind extends NodeKind> = makeRootAndArrayPropertiesMutable<NormalizedSchema<kind>>;
+export type errorContext<kind extends NodeKind> = Declaration<kind>["errorContext"];
+export {};

package/node_modules/@ark/schema/out/kinds.js

@@ -0,0 +1,71 @@
+import { deepClone, envHasCsp, flatMorph, withAlphabetizedKeys } from "@ark/util";
+import { mergeConfigs } from "./config.js";
+import { Predicate } from "./predicate.js";
+import { Divisor } from "./refinements/divisor.js";
+import { boundClassesByKind, boundImplementationsByKind } from "./refinements/kinds.js";
+import { Pattern } from "./refinements/pattern.js";
+import { Alias } from "./roots/alias.js";
+import { Domain } from "./roots/domain.js";
+import { Intersection } from "./roots/intersection.js";
+import { Morph } from "./roots/morph.js";
+import { Proto } from "./roots/proto.js";
+import { Union } from "./roots/union.js";
+import { Unit } from "./roots/unit.js";
+import { $ark } from "./shared/registry.js";
+import { ToJsonSchema } from "./shared/toJsonSchema.js";
+import { Index } from "./structure/index.js";
+import { Optional } from "./structure/optional.js";
+import { Required } from "./structure/required.js";
+import { Sequence } from "./structure/sequence.js";
+import { Structure } from "./structure/structure.js";
+export const nodeImplementationsByKind = {
+    ...boundImplementationsByKind,
+    alias: Alias.implementation,
+    domain: Domain.implementation,
+    unit: Unit.implementation,
+    proto: Proto.implementation,
+    union: Union.implementation,
+    morph: Morph.implementation,
+    intersection: Intersection.implementation,
+    divisor: Divisor.implementation,
+    pattern: Pattern.implementation,
+    predicate: Predicate.implementation,
+    required: Required.implementation,
+    optional: Optional.implementation,
+    index: Index.implementation,
+    sequence: Sequence.implementation,
+    structure: Structure.implementation
+};
+$ark.defaultConfig = withAlphabetizedKeys(Object.assign(flatMorph(nodeImplementationsByKind, (kind, implementation) => [
+    kind,
+    implementation.defaults
+]), {
+    jitless: envHasCsp(),
+    clone: deepClone,
+    onUndeclaredKey: "ignore",
+    exactOptionalPropertyTypes: true,
+    numberAllowsNaN: false,
+    dateAllowsInvalid: false,
+    onFail: null,
+    keywords: {},
+    toJsonSchema: ToJsonSchema.defaultConfig
+}));
+$ark.resolvedConfig = mergeConfigs($ark.defaultConfig, $ark.config);
+export const nodeClassesByKind = {
+    ...boundClassesByKind,
+    alias: Alias.Node,
+    domain: Domain.Node,
+    unit: Unit.Node,
+    proto: Proto.Node,
+    union: Union.Node,
+    morph: Morph.Node,
+    intersection: Intersection.Node,
+    divisor: Divisor.Node,
+    pattern: Pattern.Node,
+    predicate: Predicate.Node,
+    required: Required.Node,
+    optional: Optional.Node,
+    index: Index.Node,
+    sequence: Sequence.Node,
+    structure: Structure.Node
+};

package/node_modules/@ark/schema/out/module.d.ts

@@ -0,0 +1,24 @@
+import { DynamicBase, type anyOrNever } from "@ark/util";
+import type { BaseRoot } from "./roots/root.ts";
+import type { BaseScope, InternalResolution, InternalResolutions } from "./scope.ts";
+import { arkKind } from "./shared/utils.ts";
+export type PreparsedNodeResolution = {
+    [arkKind]: "generic" | "module";
+};
+export declare class RootModule<exports extends {} = {}> extends DynamicBase<exports> {
+    get [arkKind](): "module";
+}
+export interface InternalModule<exports extends InternalResolutions = InternalResolutions> extends RootModule<exports> {
+    root?: BaseRoot;
+}
+export declare const bindModule: (module: InternalModule, $: BaseScope) => InternalModule;
+type exportSchemaScope<$> = {
+    [k in keyof $]: instantiateRoot<$[k]>;
+};
+export type instantiateRoot<t> = t extends InternalResolution ? [
+    t
+] extends [anyOrNever] ? BaseRoot : t : BaseRoot;
+export declare const SchemaModule: new <$ = {}>(types: exportSchemaScope<$>) => SchemaModule<$>;
+export interface SchemaModule<$ = {}> extends RootModule<exportSchemaScope<$>> {
+}
+export {};

package/node_modules/@ark/schema/out/module.js

@@ -0,0 +1,15 @@
+import { DynamicBase, flatMorph } from "@ark/util";
+import { arkKind, hasArkKind } from "./shared/utils.js";
+export class RootModule extends DynamicBase {
+    // ensure `[arkKind]` is non-enumerable so it doesn't get spread on import/export
+    get [arkKind]() {
+        return "module";
+    }
+}
+export const bindModule = (module, $) => new RootModule(flatMorph(module, (alias, value) => [
+    alias,
+    hasArkKind(value, "module") ?
+        bindModule(value, $)
+        : $.bindReference(value)
+]));
+export const SchemaModule = RootModule;

package/node_modules/@ark/schema/out/node.d.ts

@@ -0,0 +1,154 @@
+import { Callable, type GuardablePredicate, type JsonStructure, type Key, type array, type conform, type listable, type mutable, type requireKeys } from "@ark/util";
+import type { BaseConstraint } from "./constraint.ts";
+import type { Inner, NormalizedSchema, childKindOf, nodeOfKind, reducibleKindOf } from "./kinds.ts";
+import type { BaseParseOptions } from "./parse.ts";
+import type { Intersection } from "./roots/intersection.ts";
+import type { Morph } from "./roots/morph.ts";
+import type { BaseRoot } from "./roots/root.ts";
+import type { Unit } from "./roots/unit.ts";
+import type { BaseScope } from "./scope.ts";
+import type { NodeCompiler } from "./shared/compile.ts";
+import type { BaseNodeDeclaration, TypeMeta, attachmentsOf } from "./shared/declare.ts";
+import type { ArkErrors } from "./shared/errors.ts";
+import { type BasisKind, type NodeKind, type OpenNodeKind, type RefinementKind, type StructuralKind, type UnknownAttachments } from "./shared/implement.ts";
+import { Traversal, type TraverseAllows, type TraverseApply } from "./shared/traversal.ts";
+import type { UndeclaredKeyHandling } from "./structure/structure.ts";
+export declare abstract class BaseNode<
+/** @ts-ignore allow instantiation assignment to the base type */
+out d extends BaseNodeDeclaration = BaseNodeDeclaration> extends Callable<(data: d["prerequisite"], ctx?: Traversal, onFail?: ArkErrors.Handler | null) => unknown, attachmentsOf<d>> {
+    attachments: UnknownAttachments;
+    $: BaseScope;
+    onFail: ArkErrors.Handler | null;
+    includesTransform: boolean;
+    includesContextualPredicate: boolean;
+    isCyclic: boolean;
+    allowsRequiresContext: boolean;
+    rootApplyStrategy: "allows" | "contextual" | "optimistic" | "branchedOptimistic";
+    contextFreeMorph: ((data: unknown) => unknown) | undefined;
+    rootApply: (data: unknown, onFail: ArkErrors.Handler | null) => unknown;
+    referencesById: Record<string, BaseNode>;
+    shallowReferences: BaseNode[];
+    flatRefs: FlatRef[];
+    flatMorphs: FlatRef<Morph.Node | Intersection.Node>[];
+    allows: (data: d["prerequisite"]) => boolean;
+    get shallowMorphs(): array<Morph>;
+    constructor(attachments: UnknownAttachments, $: BaseScope);
+    protected createRootApply(): this["rootApply"];
+    abstract traverseAllows: TraverseAllows<d["prerequisite"]>;
+    abstract traverseApply: TraverseApply<d["prerequisite"]>;
+    abstract expression: string;
+    abstract compile(js: NodeCompiler): void;
+    readonly compiledMeta: string;
+    protected cacheGetter<name extends keyof this>(name: name, value: this[name]): this[name];
+    get description(): string;
+    get references(): BaseNode[];
+    readonly precedence: number;
+    precompilation: string | undefined;
+    assert: (data: d["prerequisite"], pipedFromCtx?: Traversal) => unknown;
+    traverse(data: d["prerequisite"], pipedFromCtx?: Traversal): ArkErrors | {} | null | undefined;
+    /** rawIn should be used internally instead */
+    get in(): unknown;
+    get rawIn(): BaseNode;
+    /** rawOut should be used internally instead */
+    get out(): unknown;
+    get rawOut(): BaseNode;
+    getIo(ioKind: "in" | "out"): BaseNode;
+    toJSON(): JsonStructure;
+    toString(): string;
+    equals(r: unknown): boolean;
+    ifEquals(r: unknown): BaseNode | undefined;
+    hasKind<kind extends NodeKind>(kind: kind): this is nodeOfKind<kind>;
+    assertHasKind<kind extends NodeKind>(kind: kind): nodeOfKind<kind>;
+    hasKindIn<kinds extends NodeKind[]>(...kinds: kinds): this is nodeOfKind<kinds[number]>;
+    assertHasKindIn<kinds extends NodeKind[]>(...kinds: kinds): nodeOfKind<kinds[number]>;
+    isBasis(): this is nodeOfKind<BasisKind>;
+    isConstraint(): this is BaseConstraint;
+    isStructural(): this is nodeOfKind<StructuralKind>;
+    isRefinement(): this is nodeOfKind<RefinementKind>;
+    isRoot(): this is BaseRoot;
+    isUnknown(): boolean;
+    isNever(): boolean;
+    hasUnit<value>(value: unknown): this is Unit.Node & {
+        unit: value;
+    };
+    hasOpenIntersection(): this is nodeOfKind<OpenNodeKind>;
+    get nestableExpression(): string;
+    select<const selector extends NodeSelector.CompositeInput, predicate extends GuardablePredicate<NodeSelector.inferSelectKind<d["kind"], selector>>>(selector: NodeSelector.validateComposite<selector, predicate>): NodeSelector.infer<d["kind"], selector>;
+    select<const selector extends NodeSelector.Single>(selector: selector): NodeSelector.infer<d["kind"], selector>;
+    private _select;
+    transform<mapper extends DeepNodeTransformation>(mapper: mapper, opts?: DeepNodeTransformOptions): nodeOfKind<reducibleKindOf<this["kind"]>> | Extract<ReturnType<mapper>, null>;
+    protected _createTransformContext(opts: DeepNodeTransformOptions | undefined): DeepNodeTransformContext;
+    protected _transform(mapper: DeepNodeTransformation, ctx: DeepNodeTransformContext): BaseNode | null;
+    configureReferences(meta: TypeMeta.MappableInput.Internal, selector?: NodeSelector): this;
+}
+/** a literal key (named property) or a node (index signatures) representing part of a type structure */
+export type KeyOrKeyNode = Key | BaseRoot;
+export type GettableKeyOrNode = KeyOrKeyNode | number;
+export type FlatRef<root extends BaseRoot = BaseRoot> = {
+    path: array<KeyOrKeyNode>;
+    node: root;
+    propString: string;
+};
+export type NodeSelector = NodeSelector.Single | NodeSelector.Composite;
+export declare namespace NodeSelector {
+    type SelectableFn<input, returns, kind extends NodeKind = NodeKind> = {
+        <const selector extends NodeSelector.CompositeInput, predicate extends GuardablePredicate<NodeSelector.inferSelectKind<kind, selector>>>(input: input, selector?: NodeSelector.validateComposite<selector, predicate>): returns;
+        <const selector extends NodeSelector.Single>(input: input, selector?: selector): returns;
+    };
+    type Single = NodeSelector.Boundary | NodeSelector.Kind | GuardablePredicate<BaseNode>;
+    type Boundary = "self" | "child" | "shallow" | "references";
+    type Kind = NodeKind;
+    type Method = "filter" | "assertFilter" | "find" | "assertFind";
+    interface Composite {
+        method?: Method;
+        boundary?: Boundary;
+        kind?: Kind;
+        where?: GuardablePredicate<BaseNode>;
+    }
+    type Normalized = requireKeys<Composite, "method" | "boundary">;
+    type CompositeInput = Omit<Composite, "where">;
+    type BaseResult = BaseNode | BaseNode[] | undefined;
+    type validateComposite<selector, predicate> = {
+        [k in keyof selector]: k extends "where" ? predicate : conform<selector[k], CompositeInput[k & keyof CompositeInput]>;
+    };
+    type infer<selfKind extends NodeKind, selector> = applyMethod<selector extends NodeSelector.WhereCastInput<any, infer narrowed> ? narrowed : NodeSelector.inferSelectKind<selfKind, selector>, selector>;
+    type BoundaryInput<b extends Boundary> = b | {
+        boundary: b;
+    };
+    type KindInput<k extends Kind> = k | {
+        kind: k;
+    };
+    type WhereCastInput<kindNode extends BaseNode, narrowed extends kindNode> = ((In: kindNode) => In is narrowed) | {
+        where: (In: kindNode) => In is narrowed;
+    };
+    type inferSelectKind<selfKind extends NodeKind, selector> = selectKind<selfKind, selector> extends infer kind extends NodeKind ? NodeKind extends kind ? BaseNode : nodeOfKind<kind> : never;
+    type selectKind<selfKind extends NodeKind, selector> = selector extends BoundaryInput<"self"> ? selfKind : selector extends KindInput<infer kind> ? kind : selector extends BoundaryInput<"child"> ? selfKind | childKindOf<selfKind> : NodeKind;
+    type applyMethod<t, selector> = selector extends {
+        method: infer method extends Method;
+    } ? method extends "filter" ? t[] : method extends "assertFilter" ? [t, ...t[]] : method extends "find" ? t | undefined : method extends "assertFind" ? t : never : t[];
+}
+export declare const typePathToPropString: (path: array<KeyOrKeyNode>) => string;
+export declare const flatRef: <node extends BaseRoot>(path: array<KeyOrKeyNode>, node: node) => FlatRef<node>;
+export declare const flatRefsAreEqual: (l: FlatRef, r: FlatRef) => boolean;
+export declare const appendUniqueFlatRefs: <node extends BaseRoot>(existing: FlatRef<node>[] | undefined, refs: listable<FlatRef<node>>) => FlatRef<node>[];
+export declare const appendUniqueNodes: <node extends BaseNode>(existing: node[] | undefined, refs: listable<node>) => node[];
+export type DeepNodeTransformOptions = {
+    shouldTransform?: ShouldTransformFn;
+    bindScope?: BaseScope;
+    prereduced?: boolean;
+    selected?: readonly BaseNode[] | undefined;
+};
+export type ShouldTransformFn = (node: BaseNode, ctx: DeepNodeTransformContext) => boolean;
+export interface DeepNodeTransformContext extends DeepNodeTransformOptions {
+    root: BaseNode;
+    selected: readonly BaseNode[] | undefined;
+    path: mutable<array<KeyOrKeyNode>>;
+    seen: {
+        [originalId: string]: (() => BaseNode | undefined) | undefined;
+    };
+    parseOptions: BaseParseOptions;
+    undeclaredKeyHandling: UndeclaredKeyHandling | undefined;
+}
+export type DeepNodeTransformation = <kind extends NodeKind>(kind: kind, innerWithMeta: Inner<kind> & {
+    meta: ArkEnv.meta;
+}, ctx: DeepNodeTransformContext) => NormalizedSchema<kind> | null;