@blade-hq/agent-client 1.1.1 → 1.1.2

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

@@ -0,0 +1,438 @@
+import { Callable, appendUnique, flatMorph, includes, isArray, isEmptyObject, isKeyOf, liftArray, printable, stringifyPath, throwError, throwInternalError } from "@ark/util";
+import { basisKinds, constraintKinds, precedenceOfKind, refinementKinds, rootKinds, structuralKinds } from "./shared/implement.js";
+import { $ark } from "./shared/registry.js";
+import { Traversal } from "./shared/traversal.js";
+import { isNode } from "./shared/utils.js";
+export class BaseNode extends Callable {
+    attachments;
+    $;
+    onFail;
+    includesTransform;
+    includesContextualPredicate;
+    isCyclic;
+    allowsRequiresContext;
+    rootApplyStrategy;
+    contextFreeMorph;
+    rootApply;
+    referencesById;
+    shallowReferences;
+    flatRefs;
+    flatMorphs;
+    allows;
+    get shallowMorphs() {
+        return [];
+    }
+    constructor(attachments, $) {
+        super((data, pipedFromCtx, onFail = this.onFail) => {
+            if (pipedFromCtx) {
+                this.traverseApply(data, pipedFromCtx);
+                return pipedFromCtx.hasError() ?
+                    pipedFromCtx.errors
+                    : pipedFromCtx.data;
+            }
+            return this.rootApply(data, onFail);
+        }, { attach: attachments });
+        this.attachments = attachments;
+        this.$ = $;
+        this.onFail = this.meta.onFail ?? this.$.resolvedConfig.onFail;
+        this.includesTransform =
+            this.hasKind("morph") ||
+                (this.hasKind("structure") && this.structuralMorph !== undefined) ||
+                (this.hasKind("sequence") && this.inner.defaultables !== undefined);
+        // if a predicate accepts exactly one arg, we can safely skip passing context
+        // technically, a predicate could be written like `(data, ...[ctx]) => ctx.mustBe("malicious")`
+        // that would break here, but it feels like a pathological case and is better to let people optimize
+        this.includesContextualPredicate =
+            this.hasKind("predicate") && this.inner.predicate.length !== 1;
+        this.isCyclic = this.kind === "alias";
+        this.referencesById = { [this.id]: this };
+        this.shallowReferences =
+            this.hasKind("structure") ?
+                [this, ...this.children]
+                : this.children.reduce((acc, child) => appendUniqueNodes(acc, child.shallowReferences), [this]);
+        const isStructural = this.isStructural();
+        this.flatRefs = [];
+        this.flatMorphs = [];
+        for (let i = 0; i < this.children.length; i++) {
+            this.includesTransform ||= this.children[i].includesTransform;
+            this.includesContextualPredicate ||=
+                this.children[i].includesContextualPredicate;
+            this.isCyclic ||= this.children[i].isCyclic;
+            if (!isStructural) {
+                const childFlatRefs = this.children[i].flatRefs;
+                for (let j = 0; j < childFlatRefs.length; j++) {
+                    const childRef = childFlatRefs[j];
+                    if (!this.flatRefs.some(existing => flatRefsAreEqual(existing, childRef))) {
+                        this.flatRefs.push(childRef);
+                        for (const branch of childRef.node.branches) {
+                            if (branch.hasKind("morph") ||
+                                (branch.hasKind("intersection") &&
+                                    branch.structure?.structuralMorph !== undefined)) {
+                                this.flatMorphs.push({
+                                    path: childRef.path,
+                                    propString: childRef.propString,
+                                    node: branch
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            Object.assign(this.referencesById, this.children[i].referencesById);
+        }
+        this.flatRefs.sort((l, r) => l.path.length > r.path.length ? 1
+            : l.path.length < r.path.length ? -1
+                : l.propString > r.propString ? 1
+                    : l.propString < r.propString ? -1
+                        : l.node.expression < r.node.expression ? -1
+                            : 1);
+        this.allowsRequiresContext =
+            this.includesContextualPredicate || this.isCyclic;
+        this.rootApplyStrategy =
+            !this.allowsRequiresContext && this.flatMorphs.length === 0 ?
+                this.shallowMorphs.length === 0 ? "allows"
+                    : (this.shallowMorphs.every(morph => morph.length === 1 || morph.name === "$arkStructuralMorph")) ?
+                        this.hasKind("union") ?
+                            // multiple morphs not yet supported for optimistic compilation
+                            this.branches.some(branch => branch.shallowMorphs.length > 1) ?
+                                "contextual"
+                                : "branchedOptimistic"
+                            : this.shallowMorphs.length > 1 ? "contextual"
+                                : "optimistic"
+                        : "contextual"
+                : "contextual";
+        this.rootApply = this.createRootApply();
+        this.allows =
+            this.allowsRequiresContext ?
+                data => this.traverseAllows(data, new Traversal(data, this.$.resolvedConfig))
+                : data => this.traverseAllows(data);
+    }
+    createRootApply() {
+        switch (this.rootApplyStrategy) {
+            case "allows":
+                return (data, onFail) => {
+                    if (this.allows(data))
+                        return data;
+                    const ctx = new Traversal(data, this.$.resolvedConfig);
+                    this.traverseApply(data, ctx);
+                    return ctx.finalize(onFail);
+                };
+            case "contextual":
+                return (data, onFail) => {
+                    const ctx = new Traversal(data, this.$.resolvedConfig);
+                    this.traverseApply(data, ctx);
+                    return ctx.finalize(onFail);
+                };
+            case "optimistic":
+                this.contextFreeMorph = this.shallowMorphs[0];
+                const clone = this.$.resolvedConfig.clone;
+                return (data, onFail) => {
+                    if (this.allows(data)) {
+                        return this.contextFreeMorph((clone &&
+                            ((typeof data === "object" && data !== null) ||
+                                typeof data === "function")) ?
+                            clone(data)
+                            : data);
+                    }
+                    const ctx = new Traversal(data, this.$.resolvedConfig);
+                    this.traverseApply(data, ctx);
+                    return ctx.finalize(onFail);
+                };
+            case "branchedOptimistic":
+                return this.createBranchedOptimisticRootApply();
+            default:
+                this.rootApplyStrategy;
+                return throwInternalError(`Unexpected rootApplyStrategy ${this.rootApplyStrategy}`);
+        }
+    }
+    compiledMeta = compileMeta(this.metaJson);
+    cacheGetter(name, value) {
+        Object.defineProperty(this, name, { value });
+        return value;
+    }
+    get description() {
+        return this.cacheGetter("description", this.meta?.description ??
+            this.$.resolvedConfig[this.kind].description(this));
+    }
+    // we don't cache this currently since it can be updated once a scope finishes
+    // resolving cyclic references, although it may be possible to ensure it is cached safely
+    get references() {
+        return Object.values(this.referencesById);
+    }
+    precedence = precedenceOfKind(this.kind);
+    precompilation;
+    // defined as an arrow function since it is often detached, e.g. when passing to tRPC
+    // otherwise, would run into issues with this binding
+    assert = (data, pipedFromCtx) => this(data, pipedFromCtx, errors => errors.throw());
+    traverse(data, pipedFromCtx) {
+        return this(data, pipedFromCtx, null);
+    }
+    /** rawIn should be used internally instead */
+    get in() {
+        // ensure the node has been finalized if in is being used externally
+        return this.cacheGetter("in", this.rawIn.isRoot() ? this.$.finalize(this.rawIn) : this.rawIn);
+    }
+    get rawIn() {
+        return this.cacheGetter("rawIn", this.getIo("in"));
+    }
+    /** rawOut should be used internally instead */
+    get out() {
+        // ensure the node has been finalized if out is being used externally
+        return this.cacheGetter("out", this.rawOut.isRoot() ? this.$.finalize(this.rawOut) : this.rawOut);
+    }
+    get rawOut() {
+        return this.cacheGetter("rawOut", this.getIo("out"));
+    }
+    // Should be refactored to use transform
+    // https://github.com/arktypeio/arktype/issues/1020
+    getIo(ioKind) {
+        if (!this.includesTransform)
+            return this;
+        const ioInner = {};
+        for (const [k, v] of this.innerEntries) {
+            const keySchemaImplementation = this.impl.keys[k];
+            if (keySchemaImplementation.reduceIo)
+                keySchemaImplementation.reduceIo(ioKind, ioInner, v);
+            else if (keySchemaImplementation.child) {
+                const childValue = v;
+                ioInner[k] =
+                    isArray(childValue) ?
+                        childValue.map(child => ioKind === "in" ? child.rawIn : child.rawOut)
+                        : ioKind === "in" ? childValue.rawIn
+                            : childValue.rawOut;
+            }
+            else
+                ioInner[k] = v;
+        }
+        return this.$.node(this.kind, ioInner);
+    }
+    toJSON() {
+        return this.json;
+    }
+    toString() {
+        return `Type<${this.expression}>`;
+    }
+    equals(r) {
+        const rNode = isNode(r) ? r : this.$.parseDefinition(r);
+        return this.innerHash === rNode.innerHash;
+    }
+    ifEquals(r) {
+        return this.equals(r) ? this : undefined;
+    }
+    hasKind(kind) {
+        return this.kind === kind;
+    }
+    assertHasKind(kind) {
+        if (this.kind !== kind)
+            throwError(`${this.kind} node was not of asserted kind ${kind}`);
+        return this;
+    }
+    hasKindIn(...kinds) {
+        return kinds.includes(this.kind);
+    }
+    assertHasKindIn(...kinds) {
+        if (!includes(kinds, this.kind))
+            throwError(`${this.kind} node was not one of asserted kinds ${kinds}`);
+        return this;
+    }
+    isBasis() {
+        return includes(basisKinds, this.kind);
+    }
+    isConstraint() {
+        return includes(constraintKinds, this.kind);
+    }
+    isStructural() {
+        return includes(structuralKinds, this.kind);
+    }
+    isRefinement() {
+        return includes(refinementKinds, this.kind);
+    }
+    isRoot() {
+        return includes(rootKinds, this.kind);
+    }
+    isUnknown() {
+        return this.hasKind("intersection") && this.children.length === 0;
+    }
+    isNever() {
+        return this.hasKind("union") && this.children.length === 0;
+    }
+    hasUnit(value) {
+        return this.hasKind("unit") && this.allows(value);
+    }
+    hasOpenIntersection() {
+        return this.impl.intersectionIsOpen;
+    }
+    get nestableExpression() {
+        return this.expression;
+    }
+    select(selector) {
+        const normalized = NodeSelector.normalize(selector);
+        return this._select(normalized);
+    }
+    _select(selector) {
+        let nodes = NodeSelector.applyBoundary[selector.boundary ?? "references"](this);
+        if (selector.kind)
+            nodes = nodes.filter(n => n.kind === selector.kind);
+        if (selector.where)
+            nodes = nodes.filter(selector.where);
+        return NodeSelector.applyMethod[selector.method ?? "filter"](nodes, this, selector);
+    }
+    transform(mapper, opts) {
+        return this._transform(mapper, this._createTransformContext(opts));
+    }
+    _createTransformContext(opts) {
+        return {
+            root: this,
+            selected: undefined,
+            seen: {},
+            path: [],
+            parseOptions: {
+                prereduced: opts?.prereduced ?? false
+            },
+            undeclaredKeyHandling: undefined,
+            ...opts
+        };
+    }
+    _transform(mapper, ctx) {
+        const $ = ctx.bindScope ?? this.$;
+        if (ctx.seen[this.id])
+            // Cyclic handling needs to be made more robust
+            // https://github.com/arktypeio/arktype/issues/944
+            return this.$.lazilyResolve(ctx.seen[this.id]);
+        if (ctx.shouldTransform?.(this, ctx) === false)
+            return this;
+        let transformedNode;
+        ctx.seen[this.id] = () => transformedNode;
+        if (this.hasKind("structure") &&
+            this.undeclared !== ctx.undeclaredKeyHandling) {
+            ctx = {
+                ...ctx,
+                undeclaredKeyHandling: this.undeclared
+            };
+        }
+        const innerWithTransformedChildren = flatMorph(this.inner, (k, v) => {
+            if (!this.impl.keys[k].child)
+                return [k, v];
+            const children = v;
+            if (!isArray(children)) {
+                const transformed = children._transform(mapper, ctx);
+                return transformed ? [k, transformed] : [];
+            }
+            // if the value was previously explicitly set to an empty list,
+            // (e.g. branches for `never`), ensure it is not pruned
+            if (children.length === 0)
+                return [k, v];
+            const transformed = children.flatMap(n => {
+                const transformedChild = n._transform(mapper, ctx);
+                return transformedChild ?? [];
+            });
+            return transformed.length ? [k, transformed] : [];
+        });
+        delete ctx.seen[this.id];
+        const innerWithMeta = Object.assign(innerWithTransformedChildren, {
+            meta: this.meta
+        });
+        const transformedInner = ctx.selected && !ctx.selected.includes(this) ?
+            innerWithMeta
+            : mapper(this.kind, innerWithMeta, ctx);
+        if (transformedInner === null)
+            return null;
+        if (isNode(transformedInner))
+            return (transformedNode = transformedInner);
+        const transformedKeys = Object.keys(transformedInner);
+        const hasNoTypedKeys = transformedKeys.length === 0 ||
+            (transformedKeys.length === 1 && transformedKeys[0] === "meta");
+        if (hasNoTypedKeys &&
+            // if inner was previously an empty object (e.g. unknown) ensure it is not pruned
+            !isEmptyObject(this.inner))
+            return null;
+        if ((this.kind === "required" ||
+            this.kind === "optional" ||
+            this.kind === "index") &&
+            !("value" in transformedInner)) {
+            return ctx.undeclaredKeyHandling ?
+                { ...transformedInner, value: $ark.intrinsic.unknown }
+                : null;
+        }
+        if (this.kind === "morph") {
+            ;
+            transformedInner.in ??= $ark.intrinsic
+                .unknown;
+        }
+        return (transformedNode = $.node(this.kind, transformedInner, ctx.parseOptions));
+    }
+    configureReferences(meta, selector = "references") {
+        const normalized = NodeSelector.normalize(selector);
+        const mapper = (typeof meta === "string" ?
+            (kind, inner) => ({
+                ...inner,
+                meta: { ...inner.meta, description: meta }
+            })
+            : typeof meta === "function" ?
+                (kind, inner) => ({ ...inner, meta: meta(inner.meta) })
+                : (kind, inner) => ({
+                    ...inner,
+                    meta: { ...inner.meta, ...meta }
+                }));
+        if (normalized.boundary === "self") {
+            return this.$.node(this.kind, mapper(this.kind, { ...this.inner, meta: this.meta }));
+        }
+        const rawSelected = this._select(normalized);
+        const selected = rawSelected && liftArray(rawSelected);
+        const shouldTransform = normalized.boundary === "child" ?
+            (node, ctx) => ctx.root.children.includes(node)
+            : normalized.boundary === "shallow" ? node => node.kind !== "structure"
+                : () => true;
+        return this.$.finalize(this.transform(mapper, {
+            shouldTransform,
+            selected
+        }));
+    }
+}
+const NodeSelector = {
+    applyBoundary: {
+        self: node => [node],
+        child: node => [...node.children],
+        shallow: node => [...node.shallowReferences],
+        references: node => [...node.references]
+    },
+    applyMethod: {
+        filter: nodes => nodes,
+        assertFilter: (nodes, from, selector) => {
+            if (nodes.length === 0)
+                throwError(writeSelectAssertionMessage(from, selector));
+            return nodes;
+        },
+        find: nodes => nodes[0],
+        assertFind: (nodes, from, selector) => {
+            if (nodes.length === 0)
+                throwError(writeSelectAssertionMessage(from, selector));
+            return nodes[0];
+        }
+    },
+    normalize: (selector) => typeof selector === "function" ?
+        { boundary: "references", method: "filter", where: selector }
+        : typeof selector === "string" ?
+            isKeyOf(selector, NodeSelector.applyBoundary) ?
+                { method: "filter", boundary: selector }
+                : { boundary: "references", method: "filter", kind: selector }
+            : { boundary: "references", method: "filter", ...selector }
+};
+const writeSelectAssertionMessage = (from, selector) => `${from} had no references matching ${printable(selector)}.`;
+export const typePathToPropString = (path) => stringifyPath(path, {
+    stringifyNonKey: node => node.expression
+});
+const referenceMatcher = /"(\$ark\.[^"]+)"/g;
+const compileMeta = (metaJson) => JSON.stringify(metaJson).replace(referenceMatcher, "$1");
+export const flatRef = (path, node) => ({
+    path,
+    node,
+    propString: typePathToPropString(path)
+});
+export const flatRefsAreEqual = (l, r) => l.propString === r.propString && l.node.equals(r.node);
+export const appendUniqueFlatRefs = (existing, refs) => appendUnique(existing, refs, {
+    isEqual: flatRefsAreEqual
+});
+export const appendUniqueNodes = (existing, refs) => appendUnique(existing, refs, {
+    isEqual: (l, r) => l.equals(r)
+});

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

@@ -0,0 +1,52 @@
+import { type Brand, type dict } from "@ark/util";
+import { type NormalizedSchema } from "./kinds.ts";
+import type { BaseNode } from "./node.ts";
+import type { BaseRoot } from "./roots/root.ts";
+import type { BaseScope } from "./scope.ts";
+import { type NodeKind, type RootKind } from "./shared/implement.ts";
+import { type arkKind } from "./shared/utils.ts";
+export type ContextualArgs = Record<string, BaseRoot | NodeId>;
+export type BaseParseOptions<prereduced extends boolean = boolean> = {
+    alias?: string;
+    prereduced?: prereduced;
+    args?: ContextualArgs;
+    id?: NodeId;
+};
+export interface BaseParseContextInput extends BaseParseOptions {
+    prefix: string;
+    def: unknown;
+}
+export interface AttachedParseContext {
+    [arkKind]: "context";
+    $: BaseScope;
+    id: NodeId;
+    phase: "unresolved" | "resolving" | "resolved";
+}
+export interface BaseParseContext extends BaseParseContextInput, AttachedParseContext {
+    id: NodeId;
+}
+export interface NodeParseContextInput<kind extends NodeKind = NodeKind> extends BaseParseContextInput {
+    kind: kind;
+    def: NormalizedSchema<kind>;
+}
+export interface NodeParseContext<kind extends NodeKind = NodeKind> extends NodeParseContextInput<kind>, AttachedParseContext {
+    id: NodeId;
+}
+export declare const schemaKindOf: <kind extends RootKind = RootKind>(schema: unknown, allowedKinds?: readonly kind[]) => kind;
+export declare const writeInvalidSchemaMessage: (schema: unknown) => string;
+export type NodeId = Brand<string, "NodeId">;
+export type NodeResolver = (id: NodeId) => BaseNode;
+export declare const nodesByRegisteredId: Record<NodeId, BaseNode | BaseParseContext | undefined>;
+export declare const registerNodeId: (prefix: string) => NodeId;
+export declare const parseNode: (ctx: NodeParseContext) => BaseNode;
+export type CreateNodeInput = {
+    id: NodeId;
+    kind: NodeKind;
+    inner: dict;
+    meta: ArkEnv.meta;
+    $: BaseScope;
+    ignoreCache?: true;
+};
+export declare const createNode: ({ id, kind, inner, meta, $, ignoreCache }: CreateNodeInput) => BaseNode;
+export declare const withId: <node extends BaseNode>(node: node, id: NodeId) => node;
+export declare const withMeta: <node extends BaseNode>(node: node, meta: ArkEnv.meta, id?: NodeId) => node;