@blade-hq/agent-client 1.1.1 → 1.1.2

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

@@ -0,0 +1,151 @@
+import { type Entry, type Json, type JsonStructure, type KeySet, type arrayIndexOf, type keySetOf, type listable, type requireKeys, type show } from "@ark/util";
+import type { NodeConfig, ResolvedUnknownNodeConfig } from "../config.ts";
+import type { Declaration, Inner, errorContext, nodeOfKind } from "../kinds.ts";
+import type { BaseNode } from "../node.ts";
+import type { NodeId, NodeParseContext } from "../parse.ts";
+import type { BaseRoot, schemaKindOrRightOf, schemaKindRightOf } from "../roots/root.ts";
+import type { BaseScope, ResolvedScopeConfig } from "../scope.ts";
+import type { Structure } from "../structure/structure.ts";
+import type { BaseErrorContext, BaseNodeDeclaration, BaseNormalizedSchema } from "./declare.ts";
+import type { Disjoint } from "./disjoint.ts";
+import { type makeRootAndArrayPropertiesMutable } from "./utils.ts";
+export declare const basisKinds: readonly ["unit", "proto", "domain"];
+export type BasisKind = (typeof basisKinds)[number];
+export declare const structuralKinds: readonly ["required", "optional", "index", "sequence"];
+export type StructuralKind = (typeof structuralKinds)[number];
+export declare const prestructuralKinds: readonly ["pattern", "divisor", "exactLength", "max", "min", "maxLength", "minLength", "before", "after"];
+export type PrestructuralKind = (typeof prestructuralKinds)[number];
+export declare const refinementKinds: readonly ["pattern", "divisor", "exactLength", "max", "min", "maxLength", "minLength", "before", "after", "structure", "predicate"];
+export type RefinementKind = (typeof refinementKinds)[number];
+export declare const constraintKinds: readonly ["pattern", "divisor", "exactLength", "max", "min", "maxLength", "minLength", "before", "after", "structure", "predicate", "required", "optional", "index", "sequence"];
+export type ConstraintKind = (typeof constraintKinds)[number];
+export declare const rootKinds: readonly ["alias", "union", "morph", "unit", "intersection", "proto", "domain"];
+export type RootKind = (typeof rootKinds)[number];
+export type NodeKind = RootKind | ConstraintKind;
+type orderedNodeKinds = [...typeof rootKinds, ...typeof constraintKinds];
+export declare const nodeKinds: orderedNodeKinds;
+export type OpenNodeKind = {
+    [k in NodeKind]: Declaration<k>["intersectionIsOpen"] extends true ? k : never;
+}[NodeKind];
+export type ClosedNodeKind = Exclude<NodeKind, OpenNodeKind>;
+export type PrimitiveKind = Exclude<RefinementKind | BasisKind, "structure">;
+export type CompositeKind = Exclude<NodeKind, PrimitiveKind>;
+export type OrderedNodeKinds = typeof nodeKinds;
+export declare const constraintKeys: KeySet<ConstraintKind>;
+export declare const structureKeys: keySetOf<Structure.Inner>;
+type RightsByKind = accumulateRightKinds<OrderedNodeKinds, {}>;
+export type kindOrRightOf<kind extends NodeKind> = kind | kindRightOf<kind>;
+export type kindLeftOf<kind extends NodeKind> = Exclude<NodeKind, kindOrRightOf<kind>>;
+export type kindOrLeftOf<kind extends NodeKind> = kind | kindLeftOf<kind>;
+type accumulateRightKinds<remaining extends readonly NodeKind[], result> = remaining extends (readonly [infer head extends NodeKind, ...infer tail extends NodeKind[]]) ? accumulateRightKinds<tail, result & {
+    [k in head]: tail[number];
+}> : result;
+export interface InternalIntersectionOptions {
+    pipe: boolean;
+}
+export interface IntersectionContext extends InternalIntersectionOptions {
+    $: BaseScope;
+    invert: boolean;
+}
+export type ConstraintIntersection<lKind extends ConstraintKind, rKind extends kindOrRightOf<lKind>> = (l: nodeOfKind<lKind>, r: nodeOfKind<rKind>, ctx: IntersectionContext) => BaseNode | Disjoint | null;
+export type ConstraintIntersectionMap<kind extends ConstraintKind> = show<{
+    [_ in kind]: ConstraintIntersection<kind, kind>;
+} & {
+    [rKind in kindRightOf<kind>]?: ConstraintIntersection<kind, rKind>;
+}>;
+export type RootIntersection<lKind extends RootKind, rKind extends schemaKindOrRightOf<lKind>> = (l: nodeOfKind<lKind>, r: nodeOfKind<rKind>, ctx: IntersectionContext) => BaseRoot | Disjoint;
+export type TypeIntersectionMap<kind extends RootKind> = {
+    [rKind in schemaKindOrRightOf<kind>]: RootIntersection<kind, rKind>;
+};
+export type IntersectionMap<kind extends NodeKind> = kind extends RootKind ? TypeIntersectionMap<kind> : ConstraintIntersectionMap<kind & ConstraintKind>;
+export type UnknownIntersectionMap = {
+    [k in NodeKind]?: (l: BaseNode, r: BaseNode, ctx: IntersectionContext) => UnknownIntersectionResult;
+};
+export type UnknownIntersectionResult = BaseNode | Disjoint | null;
+type PrecedenceByKind = {
+    [i in arrayIndexOf<OrderedNodeKinds> as OrderedNodeKinds[i]]: i;
+};
+export declare const precedenceByKind: PrecedenceByKind;
+export declare const isNodeKind: (value: unknown) => value is NodeKind;
+export declare function assertNodeKind<kind extends NodeKind>(value: BaseNode, kind: kind): asserts value is nodeOfKind<kind>;
+export type precedenceOfKind<kind extends NodeKind> = PrecedenceByKind[kind];
+export declare const precedenceOfKind: <kind extends NodeKind>(kind: kind) => precedenceOfKind<kind>;
+export type kindRightOf<kind extends NodeKind> = RightsByKind[kind];
+export declare const schemaKindsRightOf: <kind extends RootKind>(kind: kind) => schemaKindRightOf<kind>[];
+export declare const unionChildKinds: readonly [...("intersection" | "morph" | "unit" | "proto" | "domain")[], "alias"];
+export type UnionChildKind = (typeof unionChildKinds)[number];
+export declare const morphChildKinds: readonly [...("intersection" | "unit" | "proto" | "domain")[], "alias"];
+export type MorphChildKind = (typeof morphChildKinds)[number];
+export type keySchemaDefinitions<d extends BaseNodeDeclaration> = {
+    [k in keyRequiringSchemaDefinition<d>]: NodeKeyImplementation<d, k>;
+};
+type keyRequiringSchemaDefinition<d extends BaseNodeDeclaration> = Exclude<keyof d["normalizedSchema"], keyof BaseNormalizedSchema>;
+export declare const defaultValueSerializer: (v: unknown) => Json;
+export type NodeKeyImplementation<d extends BaseNodeDeclaration, k extends keyof d["normalizedSchema"], instantiated = k extends keyof d["inner"] ? Exclude<d["inner"][k], undefined> : never> = requireKeys<{
+    preserveUndefined?: true;
+    child?: boolean | ((value: instantiated) => BaseNode[]);
+    serialize?: (schema: instantiated) => Json;
+    reduceIo?: (ioKind: "in" | "out", inner: makeRootAndArrayPropertiesMutable<d["inner"]>, value: d["inner"][k]) => void;
+    parse?: (schema: Exclude<d["normalizedSchema"][k], undefined>, ctx: NodeParseContext<d["kind"]>) => instantiated | undefined;
+}, (d["normalizedSchema"][k] extends instantiated | undefined ? never : "parse") | ([instantiated] extends [listable<BaseNode>] ? "child" : never)>;
+interface CommonNodeImplementationInput<d extends BaseNodeDeclaration> {
+    kind: d["kind"];
+    keys: keySchemaDefinitions<d>;
+    normalize: (schema: d["schema"], $: BaseScope) => d["normalizedSchema"];
+    applyConfig?: (schema: d["normalizedSchema"], config: ResolvedScopeConfig) => d["normalizedSchema"];
+    hasAssociatedError: d["errorContext"] extends null ? false : true;
+    finalizeInnerJson?: (json: {
+        [k in keyof d["inner"]]: Json;
+    }) => JsonStructure;
+    collapsibleKey?: keyof d["inner"];
+    reduce?: (inner: d["inner"], $: BaseScope) => nodeOfKind<d["reducibleTo"]> | Disjoint | undefined;
+    obviatesBasisDescription?: d["kind"] extends RefinementKind ? true : never;
+    obviatesBasisExpression?: d["kind"] extends RefinementKind ? true : never;
+}
+export interface UnknownNodeImplementation extends CommonNodeImplementationInput<BaseNodeDeclaration> {
+    defaults: ResolvedUnknownNodeConfig;
+    intersectionIsOpen: boolean;
+    intersections: UnknownIntersectionMap;
+    keys: Record<string, NodeKeyImplementation<any, any>>;
+}
+export declare const compileObjectLiteral: (ctx: object) => string;
+export type nodeImplementationOf<d extends BaseNodeDeclaration> = nodeImplementationInputOf<d> & {
+    intersections: IntersectionMap<d["kind"]>;
+    intersectionIsOpen: d["intersectionIsOpen"];
+    defaults: Required<NodeConfig<d["kind"]>>;
+};
+export type nodeImplementationInputOf<d extends BaseNodeDeclaration> = CommonNodeImplementationInput<d> & {
+    intersections: IntersectionMap<d["kind"]>;
+    defaults: nodeSchemaaultsImplementationInputFor<d["kind"]>;
+} & (d["intersectionIsOpen"] extends true ? {
+    intersectionIsOpen: true;
+} : {}) & (d["reducibleTo"] extends d["kind"] ? {} : {
+    reduce: {};
+});
+type nodeSchemaaultsImplementationInputFor<kind extends NodeKind> = requireKeys<NodeConfig<kind>, "description" | (Inner<kind> extends (Omit<errorContext<kind>, keyof BaseErrorContext | "description">) ? never : "expected" & keyof NodeConfig<kind>)>;
+export type DescriptionWriter<kind extends NodeKind = NodeKind> = (node: nodeOfKind<kind>) => string;
+export interface UnknownAttachments {
+    readonly kind: NodeKind;
+    readonly impl: UnknownNodeImplementation;
+    readonly id: NodeId;
+    readonly inner: Record<string, any>;
+    readonly innerEntries: readonly Entry<string>[];
+    readonly innerJson: object;
+    readonly innerHash: string;
+    readonly meta: ArkEnv.meta;
+    readonly metaJson: object;
+    readonly json: object;
+    readonly hash: string;
+    readonly collapsibleJson: Json;
+    readonly children: BaseNode[];
+}
+export interface NarrowedAttachments<d extends BaseNodeDeclaration> extends UnknownAttachments {
+    kind: d["kind"];
+    inner: d["inner"];
+    json: JsonStructure;
+    innerJson: JsonStructure;
+    collapsibleJson: Json;
+    children: nodeOfKind<d["childKind"]>[];
+}
+export declare const implementNode: <d extends BaseNodeDeclaration = never>(_: nodeImplementationInputOf<d>) => nodeImplementationOf<d>;
+export {};

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

@@ -0,0 +1,98 @@
+import { flatMorph, printable, throwParseError } from "@ark/util";
+import { compileSerializedValue } from "./compile.js";
+import { isNode } from "./utils.js";
+export const basisKinds = ["unit", "proto", "domain"];
+export const structuralKinds = [
+    "required",
+    "optional",
+    "index",
+    "sequence"
+];
+export const prestructuralKinds = [
+    "pattern",
+    "divisor",
+    "exactLength",
+    "max",
+    "min",
+    "maxLength",
+    "minLength",
+    "before",
+    "after"
+];
+export const refinementKinds = [
+    ...prestructuralKinds,
+    "structure",
+    "predicate"
+];
+export const constraintKinds = [...refinementKinds, ...structuralKinds];
+export const rootKinds = [
+    "alias",
+    "union",
+    "morph",
+    "unit",
+    "intersection",
+    "proto",
+    "domain"
+];
+export const nodeKinds = [...rootKinds, ...constraintKinds];
+export const constraintKeys = flatMorph(constraintKinds, (i, kind) => [kind, 1]);
+export const structureKeys = flatMorph([...structuralKinds, "undeclared"], (i, k) => [k, 1]);
+export const precedenceByKind = flatMorph(nodeKinds, (i, kind) => [kind, i]);
+export const isNodeKind = (value) => typeof value === "string" && value in precedenceByKind;
+export function assertNodeKind(value, kind) {
+    const valueIsNode = isNode(value);
+    if (!valueIsNode || value.kind !== kind) {
+        throwParseError(`Expected node of kind ${kind} (was ${valueIsNode ? `${value.kind} node` : printable(value)})`);
+    }
+}
+export const precedenceOfKind = (kind) => precedenceByKind[kind];
+export const schemaKindsRightOf = (kind) => rootKinds.slice(precedenceOfKind(kind) + 1);
+export const unionChildKinds = [
+    ...schemaKindsRightOf("union"),
+    "alias"
+];
+export const morphChildKinds = [
+    ...schemaKindsRightOf("morph"),
+    "alias"
+];
+export const defaultValueSerializer = (v) => {
+    if (typeof v === "string" || typeof v === "boolean" || v === null)
+        return v;
+    if (typeof v === "number") {
+        if (Number.isNaN(v))
+            return "NaN";
+        if (v === Number.POSITIVE_INFINITY)
+            return "Infinity";
+        if (v === Number.NEGATIVE_INFINITY)
+            return "-Infinity";
+        return v;
+    }
+    return compileSerializedValue(v);
+};
+export const compileObjectLiteral = (ctx) => {
+    let result = "{ ";
+    for (const [k, v] of Object.entries(ctx))
+        result += `${k}: ${compileSerializedValue(v)}, `;
+    return result + " }";
+};
+export const implementNode = (_) => {
+    const implementation = _;
+    if (implementation.hasAssociatedError) {
+        implementation.defaults.expected ??= ctx => "description" in ctx ?
+            ctx.description
+            : implementation.defaults.description(ctx);
+        implementation.defaults.actual ??= data => printable(data);
+        implementation.defaults.problem ??= ctx => `must be ${ctx.expected}${ctx.actual ? ` (was ${ctx.actual})` : ""}`;
+        implementation.defaults.message ??= ctx => {
+            if (ctx.path.length === 0)
+                return ctx.problem;
+            const problemWithLocation = `${ctx.propString} ${ctx.problem}`;
+            if (problemWithLocation[0] === "[") {
+                // clarify paths like [1], [0][1], and ["key!"] that could be confusing
+                return `value at ${problemWithLocation}`;
+            }
+            return problemWithLocation;
+        };
+    }
+    return implementation;
+};

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

@@ -0,0 +1,10 @@
+import type { BaseNode } from "../node.ts";
+import type { BaseRoot } from "../roots/root.ts";
+import type { BaseScope } from "../scope.ts";
+import { Disjoint } from "./disjoint.ts";
+import { type IntersectionContext, type RootKind } from "./implement.ts";
+type InternalNodeIntersection<ctx> = <l extends BaseNode, r extends BaseNode>(l: l, r: r, ctx: ctx) => l["kind"] | r["kind"] extends RootKind ? BaseRoot | Disjoint : BaseNode | Disjoint | null;
+export declare const intersectNodesRoot: InternalNodeIntersection<BaseScope>;
+export declare const pipeNodesRoot: InternalNodeIntersection<BaseScope>;
+export declare const intersectOrPipeNodes: InternalNodeIntersection<IntersectionContext>;
+export {};

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

@@ -0,0 +1,132 @@
+import { Disjoint } from "./disjoint.js";
+import { rootKinds } from "./implement.js";
+import { isNode } from "./utils.js";
+const intersectionCache = {};
+export const intersectNodesRoot = (l, r, $) => intersectOrPipeNodes(l, r, {
+    $,
+    invert: false,
+    pipe: false
+});
+export const pipeNodesRoot = (l, r, $) => intersectOrPipeNodes(l, r, {
+    $,
+    invert: false,
+    pipe: true
+});
+export const intersectOrPipeNodes = ((l, r, ctx) => {
+    const operator = ctx.pipe ? "|>" : "&";
+    const lrCacheKey = `${l.hash}${operator}${r.hash}`;
+    if (intersectionCache[lrCacheKey] !== undefined)
+        return intersectionCache[lrCacheKey];
+    if (!ctx.pipe) {
+        // we can only use this for the commutative & operator
+        const rlCacheKey = `${r.hash}${operator}${l.hash}`;
+        if (intersectionCache[rlCacheKey] !== undefined) {
+            // if the cached result was a Disjoint and the operands originally
+            // appeared in the opposite order, we need to invert it to match
+            const rlResult = intersectionCache[rlCacheKey];
+            const lrResult = rlResult instanceof Disjoint ? rlResult.invert() : rlResult;
+            // add the lr result to the cache directly to bypass this check in the future
+            intersectionCache[lrCacheKey] = lrResult;
+            return lrResult;
+        }
+    }
+    const isPureIntersection = !ctx.pipe || (!l.includesTransform && !r.includesTransform);
+    if (isPureIntersection && l.equals(r))
+        return l;
+    let result = isPureIntersection ? _intersectNodes(l, r, ctx)
+        : l.hasKindIn(...rootKinds) ?
+            // if l is a RootNode, r will be as well
+            _pipeNodes(l, r, ctx)
+            : _intersectNodes(l, r, ctx);
+    if (isNode(result)) {
+        // if the result equals one of the operands, preserve its metadata by
+        // returning the original reference
+        if (l.equals(result))
+            result = l;
+        else if (r.equals(result))
+            result = r;
+    }
+    intersectionCache[lrCacheKey] = result;
+    return result;
+});
+const _intersectNodes = (l, r, ctx) => {
+    const leftmostKind = l.precedence < r.precedence ? l.kind : r.kind;
+    const implementation = l.impl.intersections[r.kind] ?? r.impl.intersections[l.kind];
+    if (implementation === undefined) {
+        // should be two ConstraintNodes that have no relation
+        // this could also happen if a user directly intersects a Type and a ConstraintNode,
+        // but that is not allowed by the external function signature
+        return null;
+    }
+    else if (leftmostKind === l.kind)
+        return implementation(l, r, ctx);
+    else {
+        let result = implementation(r, l, { ...ctx, invert: !ctx.invert });
+        if (result instanceof Disjoint)
+            result = result.invert();
+        return result;
+    }
+};
+const _pipeNodes = (l, r, ctx) => l.includesTransform || r.includesTransform ?
+    ctx.invert ?
+        pipeMorphed(r, l, ctx)
+        : pipeMorphed(l, r, ctx)
+    : _intersectNodes(l, r, ctx);
+const pipeMorphed = (from, to, ctx) => from.distribute(fromBranch => _pipeMorphed(fromBranch, to, ctx), results => {
+    const viableBranches = results.filter(isNode);
+    if (viableBranches.length === 0)
+        return Disjoint.init("union", from.branches, to.branches);
+    // if the input type has changed, create a new node without preserving metadata
+    if (viableBranches.length < from.branches.length ||
+        !from.branches.every((branch, i) => branch.rawIn.equals(viableBranches[i].rawIn)))
+        return ctx.$.parseSchema(viableBranches);
+    // otherwise, the input has not changed so preserve metadata
+    let meta;
+    if (viableBranches.length === 1) {
+        const onlyBranch = viableBranches[0];
+        if (!meta)
+            return onlyBranch;
+        return ctx.$.node("morph", {
+            ...onlyBranch.inner,
+            in: onlyBranch.rawIn.configure(meta, "self")
+        });
+    }
+    const schema = {
+        branches: viableBranches
+    };
+    if (meta)
+        schema.meta = meta;
+    return ctx.$.parseSchema(schema);
+});
+const _pipeMorphed = (from, to, ctx) => {
+    const fromIsMorph = from.hasKind("morph");
+    if (fromIsMorph) {
+        const morphs = [...from.morphs];
+        if (from.lastMorphIfNode) {
+            // still piped from context, so allows appending additional morphs
+            const outIntersection = intersectOrPipeNodes(from.lastMorphIfNode, to, ctx);
+            if (outIntersection instanceof Disjoint)
+                return outIntersection;
+            morphs[morphs.length - 1] = outIntersection;
+        }
+        else
+            morphs.push(to);
+        return ctx.$.node("morph", {
+            morphs,
+            in: from.inner.in
+        });
+    }
+    if (to.hasKind("morph")) {
+        const inTersection = intersectOrPipeNodes(from, to.rawIn, ctx);
+        if (inTersection instanceof Disjoint)
+            return inTersection;
+        return ctx.$.node("morph", {
+            morphs: [to],
+            in: inTersection
+        });
+    }
+    return ctx.$.node("morph", {
+        morphs: [to],
+        in: from
+    });
+};

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

@@ -0,0 +1,93 @@
+import type { array, autocomplete, JsonArray, JsonObject, listable } from "@ark/util";
+export type JsonSchema = JsonSchema.NonBooleanBranch;
+export type ListableJsonSchema = listable<JsonSchema>;
+export type JsonSchemaOrBoolean = listable<JsonSchema.Branch>;
+export declare namespace JsonSchema {
+    type TypeName = "string" | "integer" | "number" | "object" | "array" | "boolean" | "null";
+    /**
+     *  a subset of JSON Schema's annotations, see:
+     *  https://json-schema.org/understanding-json-schema/reference/annotations
+     **/
+    interface Meta<t = unknown> extends UniversalMeta<t> {
+        $schema?: string;
+        $defs?: Record<string, JsonSchema>;
+    }
+    type Format = autocomplete<"date-time" | "date" | "time" | "email" | "ipv4" | "ipv6" | "uri" | "uuid" | "regex">;
+    /**
+     * doesn't include root-only keys like $schema
+     */
+    interface UniversalMeta<t = unknown> {
+        title?: string;
+        description?: string;
+        format?: Format;
+        deprecated?: true;
+        default?: t;
+        examples?: readonly t[];
+    }
+    type Composition = Union | OneOf | Intersection | Not;
+    type NonBooleanBranch = Constrainable | Const | Composition | Enum | String | Numeric | Object | Array | Ref;
+    type Branch = boolean | JsonSchema;
+    type RefString = `#/$defs/${string}`;
+    interface Ref extends Meta {
+        $ref: RefString;
+        type?: never;
+    }
+    interface Constrainable extends Meta {
+        type?: listable<TypeName>;
+    }
+    interface Intersection extends Meta {
+        allOf: readonly JsonSchema[];
+    }
+    interface Not extends Meta {
+        not: JsonSchema;
+    }
+    interface OneOf extends Meta {
+        oneOf: readonly JsonSchema[];
+    }
+    interface Union extends Meta {
+        anyOf: readonly JsonSchema[];
+    }
+    interface Const extends Meta {
+        const: unknown;
+    }
+    interface Enum extends Meta {
+        enum: array;
+    }
+    interface String extends Meta<string> {
+        type: "string";
+        minLength?: number;
+        maxLength?: number;
+        pattern?: string;
+        format?: string;
+    }
+    interface Numeric extends Meta<number> {
+        type: "number" | "integer";
+        multipleOf?: number;
+        minimum?: number;
+        exclusiveMinimum?: number;
+        maximum?: number;
+        exclusiveMaximum?: number;
+    }
+    interface Object extends Meta<JsonObject> {
+        type: "object";
+        properties?: Record<string, JsonSchema>;
+        required?: string[];
+        patternProperties?: Record<string, JsonSchema>;
+        additionalProperties?: JsonSchemaOrBoolean;
+        maxProperties?: number;
+        minProperties?: number;
+        propertyNames?: String;
+    }
+    interface Array extends Meta<JsonArray> {
+        type: "array";
+        additionalItems?: JsonSchemaOrBoolean;
+        contains?: JsonSchemaOrBoolean;
+        uniqueItems?: boolean;
+        minItems?: number;
+        maxItems?: number;
+        items?: JsonSchemaOrBoolean;
+        prefixItems?: readonly Branch[];
+    }
+    type LengthBoundable = String | Array;
+    type Structure = Object | Array;
+}

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

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

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

@@ -0,0 +1,7 @@
+import { type NonNegativeIntegerLiteral } from "@ark/util";
+import type { ArkSchemaRegistry } from "../config.ts";
+export declare const registryName: string;
+export declare const $ark: ArkSchemaRegistry;
+export declare const reference: (name: string) => RegisteredReference;
+export declare const registeredReference: (value: object | symbol) => RegisteredReference;
+export type RegisteredReference<to extends string = string> = `$ark${"" | NonNegativeIntegerLiteral}.${to}`;

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

@@ -0,0 +1,10 @@
+import { register, registry } from "@ark/util";
+let _registryName = "$ark";
+let suffix = 2;
+while (_registryName in globalThis)
+    _registryName = `$ark${suffix++}`;
+export const registryName = _registryName;
+globalThis[registryName] = registry;
+export const $ark = registry;
+export const reference = (name) => `${registryName}.${name}`;
+export const registeredReference = (value) => reference(register(value));

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

@@ -0,0 +1,122 @@
+/** From https://github.com/standard-schema/standard-schema */
+/** The Standard Typed interface. This is a base type extended by other specs. */
+export interface StandardTypedV1<Input = unknown, Output = Input> {
+    /** The Standard properties. */
+    readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+export declare namespace StandardTypedV1 {
+    /** The Standard Typed properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The Standard Typed types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Typed. */
+    type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    /** Infers the output type of a Standard Typed. */
+    type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** A falsy value for `issues` indicates success. */
+        readonly issues?: undefined;
+    }
+    interface Options {
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard types interface. */
+    interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+    }
+    /** Infers the input type of a Standard. */
+    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+    /** Infers the output type of a Standard. */
+    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+    /** ArkType-specific properties that extend the standard schema with JSON Schema support. */
+    interface ArkTypeProps<Input = unknown, Output = Input> extends Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {
+        vendor: "arktype";
+    }
+}
+/** The Standard JSON Schema interface. */
+export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard JSON Schema properties. */
+    readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardJSONSchemaV1 {
+    /** The Standard JSON Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+        /** Methods for generating the input/output JSON Schema. */
+        readonly jsonSchema: StandardJSONSchemaV1.Converter;
+    }
+    /** The Standard JSON Schema converter interface. */
+    interface Converter {
+        /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+        readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+        /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+        readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    }
+    /**
+     * The target version of the generated JSON Schema.
+     *
+     * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use. All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+     *
+     * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+     */
+    type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
+    /** The options for the input/output methods. */
+    interface Options {
+        /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+        readonly target: Target;
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The Standard types interface. */
+    interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+    }
+    /** Infers the input type of a Standard. */
+    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+    /** Infers the output type of a Standard. */
+    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}

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

@@ -0,0 +1,2 @@
+/** From https://github.com/standard-schema/standard-schema */
+export {};