@blade-hq/agent-client 1.1.1 → 1.1.3

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

@@ -0,0 +1,58 @@
+import type { ArkRegistry, requireKeys, show } from "@ark/util";
+import type { intrinsic } from "./intrinsic.ts";
+import type { nodesByRegisteredId } from "./parse.ts";
+import type { TypeMeta } from "./shared/declare.ts";
+import type { ActualConfig, ArkErrorCode, ArkErrors, ExpectedConfig, MessageConfig, ProblemConfig } from "./shared/errors.ts";
+import { type DescriptionWriter, type NodeKind } from "./shared/implement.ts";
+import { ToJsonSchema } from "./shared/toJsonSchema.ts";
+import type { UndeclaredKeyBehavior } from "./structure/structure.ts";
+export interface ArkSchemaRegistry extends ArkRegistry {
+    intrinsic: typeof intrinsic;
+    config: ArkSchemaConfig;
+    defaultConfig: ResolvedConfig;
+    resolvedConfig: ResolvedConfig;
+    nodesByRegisteredId: typeof nodesByRegisteredId;
+}
+type nodeConfigForKind<kind extends NodeKind> = Readonly<show<{
+    description?: DescriptionWriter<kind>;
+} & (kind extends ArkErrorCode ? {
+    expected?: ExpectedConfig<kind>;
+    actual?: ActualConfig<kind>;
+    problem?: ProblemConfig<kind>;
+    message?: MessageConfig<kind>;
+} : {})>>;
+type NodeConfigsByKind = {
+    [kind in NodeKind]: nodeConfigForKind<kind>;
+};
+export type NodeConfig<kind extends NodeKind = NodeKind> = NodeConfigsByKind[kind];
+export interface UnknownErrorConfigs {
+    expected?: ExpectedConfig;
+    actual?: ActualConfig;
+    problem?: ProblemConfig;
+    message?: MessageConfig;
+}
+interface UnknownNodeConfig extends UnknownErrorConfigs {
+    description?: DescriptionWriter;
+}
+export type ResolvedUnknownNodeConfig = requireKeys<UnknownNodeConfig, "description">;
+export declare const configureSchema: (config: ArkSchemaConfig) => ArkSchemaConfig;
+export declare const mergeConfigs: <base extends ArkSchemaConfig>(base: base, merged: ArkSchemaConfig | undefined) => base;
+type MergeToJsonSchemaConfigs = <base extends ToJsonSchema.Options | undefined>(baseConfig: base, mergedConfig: ToJsonSchema.Options | undefined) => base extends ToJsonSchema.Context ? ToJsonSchema.Context : ToJsonSchema.Options;
+export declare const mergeToJsonSchemaConfigs: MergeToJsonSchemaConfigs;
+export type CloneImplementation = <original extends object>(original: original) => original;
+export interface ArkSchemaConfig extends Partial<Readonly<NodeConfigsByKind>> {
+    readonly jitless?: boolean;
+    readonly clone?: boolean | CloneImplementation;
+    readonly onUndeclaredKey?: UndeclaredKeyBehavior;
+    readonly numberAllowsNaN?: boolean;
+    readonly dateAllowsInvalid?: boolean;
+    readonly exactOptionalPropertyTypes?: boolean;
+    readonly onFail?: ArkErrors.Handler | null;
+    readonly keywords?: Record<string, TypeMeta.Collapsible | undefined>;
+    readonly toJsonSchema?: ToJsonSchema.Options;
+}
+export type resolveConfig<config extends ArkSchemaConfig> = show<{
+    [k in keyof ArkSchemaConfig]-?: k extends NodeKind ? Required<config[k]> : k extends "clone" ? CloneImplementation | false : k extends "keywords" ? Record<string, TypeMeta | undefined> : k extends "toJsonSchema" ? ToJsonSchema.Context : config[k];
+} & Omit<config, keyof ArkSchemaConfig>>;
+export type ResolvedConfig = resolveConfig<ArkSchemaConfig>;
+export {};

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

@@ -0,0 +1,95 @@
+import { isNodeKind } from "./shared/implement.js";
+import { $ark } from "./shared/registry.js";
+import { ToJsonSchema } from "./shared/toJsonSchema.js";
+// $ark.config could already be set if it were imported previously from the
+// dedicated config entrypoint, in which case we don't want to reinitialize it
+$ark.config ??= {};
+export const configureSchema = (config) => {
+    const result = Object.assign($ark.config, mergeConfigs($ark.config, config));
+    if ($ark.resolvedConfig)
+        $ark.resolvedConfig = mergeConfigs($ark.resolvedConfig, result);
+    return result;
+};
+export const mergeConfigs = (base, merged) => {
+    if (!merged)
+        return base;
+    const result = { ...base };
+    let k;
+    for (k in merged) {
+        const keywords = { ...base.keywords };
+        if (k === "keywords") {
+            for (const flatAlias in merged[k]) {
+                const v = merged.keywords[flatAlias];
+                if (v === undefined)
+                    continue;
+                keywords[flatAlias] = typeof v === "string" ? { description: v } : v;
+            }
+            result.keywords = keywords;
+        }
+        else if (k === "toJsonSchema") {
+            result[k] = mergeToJsonSchemaConfigs(base.toJsonSchema, merged.toJsonSchema);
+        }
+        else if (isNodeKind(k)) {
+            result[k] =
+                // not casting this makes TS compute a very inefficient
+                // type that is not needed
+                {
+                    ...base[k],
+                    ...merged[k]
+                };
+        }
+        else
+            result[k] = merged[k];
+    }
+    return result;
+};
+const jsonSchemaTargetToDialect = {
+    "draft-2020-12": "https://json-schema.org/draft/2020-12/schema",
+    "draft-07": "http://json-schema.org/draft-07/schema#"
+};
+export const mergeToJsonSchemaConfigs = ((baseConfig, mergedConfig) => {
+    if (!baseConfig)
+        return resolveTargetToDialect(mergedConfig ?? {}, undefined);
+    if (!mergedConfig)
+        return baseConfig;
+    const result = { ...baseConfig };
+    let k;
+    for (k in mergedConfig) {
+        if (k === "fallback") {
+            result.fallback = mergeFallbacks(baseConfig.fallback, mergedConfig.fallback);
+        }
+        else
+            result[k] = mergedConfig[k];
+    }
+    return resolveTargetToDialect(result, mergedConfig);
+});
+const resolveTargetToDialect = (opts, userOpts) => {
+    // If user explicitly provided a dialect, use it
+    // Otherwise, if user provided a target, resolve it to dialect
+    // If neither, use the default dialect from opts
+    if (userOpts?.dialect !== undefined)
+        return opts; // dialect was already merged
+    if (userOpts?.target !== undefined) {
+        return {
+            ...opts,
+            dialect: jsonSchemaTargetToDialect[userOpts.target]
+        };
+    }
+    return opts;
+};
+const mergeFallbacks = (base, merged) => {
+    base = normalizeFallback(base);
+    merged = normalizeFallback(merged);
+    const result = {};
+    let code;
+    for (code in ToJsonSchema.defaultConfig.fallback) {
+        result[code] =
+            merged[code] ??
+                merged.default ??
+                base[code] ??
+                base.default ??
+                ToJsonSchema.defaultConfig.fallback[code];
+    }
+    return result;
+};
+const normalizeFallback = (fallback) => typeof fallback === "function" ? { default: fallback } : (fallback ?? {});

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

@@ -0,0 +1,67 @@
+import { type array, type describe, type listable, type satisfy } from "@ark/util";
+import type { NodeSchema, Prerequisite, innerAttachedAs, nodeOfKind } from "./kinds.ts";
+import { BaseNode } from "./node.ts";
+import type { NodeParseContext } from "./parse.ts";
+import type { Intersection } from "./roots/intersection.ts";
+import type { BaseRoot } from "./roots/root.ts";
+import type { BaseScope } from "./scope.ts";
+import type { NodeCompiler } from "./shared/compile.ts";
+import type { BaseNodeDeclaration } from "./shared/declare.ts";
+import { Disjoint } from "./shared/disjoint.ts";
+import { type ConstraintKind, type IntersectionContext, type NodeKind, type RootKind, type StructuralKind, type UnknownAttachments, type kindLeftOf } 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 { arkKind } from "./shared/utils.ts";
+import type { Structure } from "./structure/structure.ts";
+export declare namespace Constraint {
+    interface Declaration extends BaseNodeDeclaration {
+        kind: ConstraintKind;
+    }
+    type ReductionResult = BaseRoot | Disjoint | Intersection.Inner.mutable;
+    interface Attachments {
+        impliedBasis: BaseRoot | null;
+        impliedSiblings?: array<BaseConstraint> | null;
+    }
+    type PrimitiveKind = Exclude<ConstraintKind, StructuralKind>;
+}
+export declare abstract class BaseConstraint<
+/** @ts-ignore allow instantiation assignment to the base type */
+out d extends Constraint.Declaration = Constraint.Declaration> extends BaseNode<d> {
+    readonly [arkKind]: "constraint";
+    constructor(attachments: UnknownAttachments, $: BaseScope);
+    abstract readonly impliedBasis: BaseRoot | null;
+    readonly impliedSiblings?: array<BaseConstraint>;
+    intersect<r extends BaseConstraint>(r: r): intersectConstraintKinds<d["kind"], r["kind"]>;
+}
+export declare abstract class InternalPrimitiveConstraint<d extends Constraint.Declaration> extends BaseConstraint<d> {
+    abstract traverseAllows: TraverseAllows<d["prerequisite"]>;
+    abstract readonly compiledCondition: string;
+    abstract readonly compiledNegation: string;
+    abstract reduceJsonSchema(base: JsonSchema.Constrainable, ctx: ToJsonSchema.Context): JsonSchema.Constrainable;
+    traverseApply: TraverseApply<d["prerequisite"]>;
+    compile(js: NodeCompiler): void;
+    get errorContext(): d["errorContext"];
+    get compiledErrorContext(): string;
+}
+export declare const constraintKeyParser: <kind extends ConstraintKind>(kind: kind) => (schema: listable<NodeSchema<kind>>, ctx: NodeParseContext) => innerAttachedAs<kind> | undefined;
+type ConstraintGroupKind = satisfy<NodeKind, "intersection" | "structure">;
+interface ConstraintIntersectionState<kind extends ConstraintGroupKind = ConstraintGroupKind> {
+    kind: kind;
+    baseInner: Record<string, unknown>;
+    l: BaseConstraint[];
+    r: BaseConstraint[];
+    roots: BaseRoot[];
+    ctx: IntersectionContext;
+}
+export declare const intersectConstraints: <kind extends ConstraintGroupKind>(s: ConstraintIntersectionState<kind>) => nodeOfKind<RootKind | Extract<kind, "structure">> | Disjoint;
+export declare const flattenConstraints: (inner: object) => BaseConstraint[];
+type FlatIntersectionInner = Intersection.Inner & Structure.Inner;
+export declare const unflattenConstraints: (constraints: array<BaseConstraint>) => FlatIntersectionInner;
+export type constraintKindLeftOf<kind extends ConstraintKind> = ConstraintKind & kindLeftOf<kind>;
+export type constraintKindOrLeftOf<kind extends ConstraintKind> = kind | constraintKindLeftOf<kind>;
+export type intersectConstraintKinds<l extends ConstraintKind, r extends ConstraintKind> = nodeOfKind<l | r | "unit" | "union"> | Disjoint | null;
+export declare const throwInvalidOperandError: (...args: Parameters<typeof writeInvalidOperandMessage>) => never;
+export declare const writeInvalidOperandMessage: <kind extends ConstraintKind, expected extends BaseRoot, actual extends BaseRoot>(kind: kind, expected: expected, actual: actual) => string;
+export type writeInvalidOperandMessage<kind extends ConstraintKind, actual> = `${Capitalize<kind>} operand must be ${describe<Prerequisite<kind>>} (was ${describe<Exclude<actual, Prerequisite<kind>>>})`;
+export {};

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

@@ -0,0 +1,136 @@
+import { append, appendUnique, capitalize, isArray, throwInternalError, throwParseError } from "@ark/util";
+import { BaseNode } from "./node.js";
+import { Disjoint } from "./shared/disjoint.js";
+import { compileObjectLiteral, constraintKeys } from "./shared/implement.js";
+import { intersectNodesRoot, intersectOrPipeNodes } from "./shared/intersections.js";
+import { $ark } from "./shared/registry.js";
+import { arkKind } from "./shared/utils.js";
+export class BaseConstraint extends BaseNode {
+    constructor(attachments, $) {
+        super(attachments, $);
+        // define as a getter to avoid it being enumerable/spreadable
+        Object.defineProperty(this, arkKind, {
+            value: "constraint",
+            enumerable: false
+        });
+    }
+    impliedSiblings;
+    intersect(r) {
+        return intersectNodesRoot(this, r, this.$);
+    }
+}
+export class InternalPrimitiveConstraint extends BaseConstraint {
+    traverseApply = (data, ctx) => {
+        if (!this.traverseAllows(data, ctx))
+            ctx.errorFromNodeContext(this.errorContext);
+    };
+    compile(js) {
+        if (js.traversalKind === "Allows")
+            js.return(this.compiledCondition);
+        else {
+            js.if(this.compiledNegation, () => js.line(`ctx.errorFromNodeContext(${this.compiledErrorContext})`));
+        }
+    }
+    get errorContext() {
+        return {
+            code: this.kind,
+            description: this.description,
+            meta: this.meta,
+            ...this.inner
+        };
+    }
+    get compiledErrorContext() {
+        return compileObjectLiteral(this.errorContext);
+    }
+}
+export const constraintKeyParser = (kind) => (schema, ctx) => {
+    if (isArray(schema)) {
+        if (schema.length === 0) {
+            // Omit empty lists as input
+            return;
+        }
+        const nodes = schema.map(schema => ctx.$.node(kind, schema));
+        // predicate order must be preserved to ensure inputs are narrowed
+        // and checked in the correct order
+        if (kind === "predicate")
+            return nodes;
+        return nodes.sort((l, r) => (l.hash < r.hash ? -1 : 1));
+    }
+    const child = ctx.$.node(kind, schema);
+    return (child.hasOpenIntersection() ? [child] : child);
+};
+export const intersectConstraints = (s) => {
+    const head = s.r.shift();
+    if (!head) {
+        let result = s.l.length === 0 && s.kind === "structure" ?
+            $ark.intrinsic.unknown.internal
+            : s.ctx.$.node(s.kind, Object.assign(s.baseInner, unflattenConstraints(s.l)), { prereduced: true });
+        for (const root of s.roots) {
+            if (result instanceof Disjoint)
+                return result;
+            result = intersectOrPipeNodes(root, result, s.ctx);
+        }
+        return result;
+    }
+    let matched = false;
+    for (let i = 0; i < s.l.length; i++) {
+        const result = intersectOrPipeNodes(s.l[i], head, s.ctx);
+        if (result === null)
+            continue;
+        if (result instanceof Disjoint)
+            return result;
+        if (result.isRoot()) {
+            s.roots.push(result);
+            s.l.splice(i);
+            return intersectConstraints(s);
+        }
+        if (!matched) {
+            s.l[i] = result;
+            matched = true;
+        }
+        else if (!s.l.includes(result)) {
+            return throwInternalError(`Unexpectedly encountered multiple distinct intersection results for refinement ${head}`);
+        }
+    }
+    if (!matched)
+        s.l.push(head);
+    if (s.kind === "intersection") {
+        if (head.impliedSiblings)
+            for (const node of head.impliedSiblings)
+                appendUnique(s.r, node);
+    }
+    return intersectConstraints(s);
+};
+export const flattenConstraints = (inner) => {
+    const result = Object.entries(inner)
+        .flatMap(([k, v]) => k in constraintKeys ? v : [])
+        .sort((l, r) => l.precedence < r.precedence ? -1
+        : l.precedence > r.precedence ? 1
+            // preserve order for predicates
+            : l.kind === "predicate" && r.kind === "predicate" ? 0
+                : l.hash < r.hash ? -1
+                    : 1);
+    return result;
+};
+export const unflattenConstraints = (constraints) => {
+    const inner = {};
+    for (const constraint of constraints) {
+        if (constraint.hasOpenIntersection()) {
+            inner[constraint.kind] = append(inner[constraint.kind], constraint);
+        }
+        else {
+            if (inner[constraint.kind]) {
+                return throwInternalError(`Unexpected intersection of closed refinements of kind ${constraint.kind}`);
+            }
+            inner[constraint.kind] = constraint;
+        }
+    }
+    return inner;
+};
+export const throwInvalidOperandError = (...args) => throwParseError(writeInvalidOperandMessage(...args));
+export const writeInvalidOperandMessage = (kind, expected, actual) => {
+    const actualDescription = actual.hasKind("morph") ? "a morph"
+        : actual.isUnknown() ? "unknown"
+            : actual.exclude(expected).defaultShortDescription;
+    return `${capitalize(kind)} operand must be ${expected.description} (was ${actualDescription})`;
+};

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

@@ -0,0 +1,73 @@
+import { Callable, type array, type Hkt, type JsonStructure } from "@ark/util";
+import type { RootSchema } from "./kinds.ts";
+import type { BaseNode } from "./node.ts";
+import type { BaseRoot } from "./roots/root.ts";
+import type { BaseScope } from "./scope.ts";
+import { arkKind } from "./shared/utils.ts";
+export type GenericParamAst<name extends string = string, constraint = unknown> = [name: name, constraint: constraint];
+export type GenericParamDef<name extends string = string> = name | readonly [name, unknown];
+export declare const parseGeneric: (paramDefs: array<GenericParamDef>, bodyDef: unknown, $: BaseScope) => GenericRoot;
+export type genericParamNames<params extends array<GenericParamAst>> = {
+    [i in keyof params]: params[i][0];
+};
+export type genericParamConstraints<params extends array<GenericParamAst>> = {
+    [i in keyof params]: params[i][1];
+};
+export type GenericArgResolutions<params extends array<GenericParamAst> = array<GenericParamAst>> = {
+    [i in keyof params as params[i & `${number}`][0]]: BaseRoot;
+};
+export declare class LazyGenericBody<argResolutions = {}, returns = unknown> extends Callable<(args: argResolutions) => returns> {
+}
+export interface GenericAst<params extends array<GenericParamAst> = array<GenericParamAst>, bodyDef = unknown, $ = unknown, arg$ = $> {
+    [arkKind]: "generic";
+    paramsAst: params;
+    bodyDef: bodyDef;
+    $: $;
+    arg$: arg$;
+    names: genericParamNames<params>;
+    t: this;
+}
+export declare class GenericRoot<params extends array<GenericParamAst> = array<GenericParamAst>, bodyDef = unknown> extends Callable<(...args: {
+    [i in keyof params]: BaseRoot;
+}) => BaseRoot> {
+    readonly [arkKind] = "generic";
+    readonly paramsAst: params;
+    readonly t: GenericAst<params, bodyDef, {}, {}>;
+    paramDefs: array<GenericParamDef>;
+    bodyDef: bodyDef;
+    $: BaseScope;
+    arg$: BaseScope;
+    baseInstantiation: BaseRoot;
+    hkt: Hkt.constructor | null;
+    description: string;
+    constructor(paramDefs: array<GenericParamDef>, bodyDef: bodyDef, $: BaseScope, arg$: BaseScope, hkt: Hkt.constructor | null);
+    defIsLazy(): this is GenericRoot<params, LazyGenericBody>;
+    protected cacheGetter<name extends keyof this>(name: name, value: this[name]): this[name];
+    get json(): JsonStructure;
+    get params(): {
+        [i in keyof params]: [params[i][0], BaseRoot];
+    };
+    get names(): genericParamNames<params>;
+    get constraints(): {
+        [i in keyof params]: BaseRoot;
+    };
+    get internal(): this;
+    get referencesById(): Record<string, BaseNode>;
+    get references(): BaseNode[];
+}
+export type genericParamSchemasToAst<schemas extends readonly GenericParamDef[]> = {
+    [i in keyof schemas]: schemas[i] extends GenericParamDef<infer name> ? [
+        name,
+        unknown
+    ] : never;
+};
+export type genericHktToConstraints<hkt extends abstract new () => Hkt> = InstanceType<hkt>["constraints"];
+export type GenericRootParser = <const paramsDef extends readonly GenericParamDef[]>(...params: paramsDef) => GenericRootBodyParser<genericParamSchemasToAst<paramsDef>>;
+export type GenericRootBodyParser<params extends array<GenericParamAst>> = {
+    <const body>(body: RootSchema): GenericRoot<params, body>;
+    <hkt extends Hkt.constructor>(instantiateDef: LazyGenericBody<GenericArgResolutions<params>>, hkt: hkt): GenericRoot<{
+        [i in keyof params]: [params[i][0], genericHktToConstraints<hkt>[i]];
+    }, InstanceType<hkt>>;
+};
+export declare const writeUnsatisfiedParameterConstraintMessage: <name extends string, constraint extends string, arg extends string>(name: name, constraint: constraint, arg: arg) => writeUnsatisfiedParameterConstraintMessage<name, constraint, arg>;
+export type writeUnsatisfiedParameterConstraintMessage<name extends string, constraint extends string, arg extends string> = `${name} must be assignable to ${constraint} (was ${arg})`;

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

@@ -0,0 +1,76 @@
+import { Callable, flatMorph, snapshot, throwParseError } from "@ark/util";
+import { $ark } from "./shared/registry.js";
+import { arkKind } from "./shared/utils.js";
+export const parseGeneric = (paramDefs, bodyDef, $) => new GenericRoot(paramDefs, bodyDef, $, $, null);
+export class LazyGenericBody extends Callable {
+}
+export class GenericRoot extends Callable {
+    [arkKind] = "generic";
+    paramDefs;
+    bodyDef;
+    $;
+    arg$;
+    baseInstantiation;
+    hkt;
+    description;
+    constructor(paramDefs, bodyDef, $, arg$, hkt) {
+        super((...args) => {
+            const argNodes = flatMorph(this.names, (i, name) => {
+                const arg = this.arg$.parse(args[i]);
+                if (!arg.extends(this.constraints[i])) {
+                    throwParseError(writeUnsatisfiedParameterConstraintMessage(name, this.constraints[i].expression, arg.expression));
+                }
+                return [name, arg];
+            });
+            if (this.defIsLazy()) {
+                const def = this.bodyDef(argNodes);
+                return this.$.parse(def);
+            }
+            return this.$.parse(bodyDef, { args: argNodes });
+        });
+        this.paramDefs = paramDefs;
+        this.bodyDef = bodyDef;
+        this.$ = $;
+        this.arg$ = arg$;
+        this.hkt = hkt;
+        this.description =
+            hkt ?
+                (new hkt().description ?? `a generic type for ${hkt.constructor.name}`)
+                : "a generic type";
+        this.baseInstantiation = this(...this.constraints);
+    }
+    defIsLazy() {
+        return this.bodyDef instanceof LazyGenericBody;
+    }
+    cacheGetter(name, value) {
+        Object.defineProperty(this, name, { value });
+        return value;
+    }
+    get json() {
+        return this.cacheGetter("json", {
+            params: this.params.map(param => param[1].isUnknown() ? param[0] : [param[0], param[1].json]),
+            body: snapshot(this.bodyDef)
+        });
+    }
+    get params() {
+        return this.cacheGetter("params", this.paramDefs.map(param => typeof param === "string" ?
+            [param, $ark.intrinsic.unknown]
+            : [param[0], this.$.parse(param[1])]));
+    }
+    get names() {
+        return this.cacheGetter("names", this.params.map(e => e[0]));
+    }
+    get constraints() {
+        return this.cacheGetter("constraints", this.params.map(e => e[1]));
+    }
+    get internal() {
+        return this;
+    }
+    get referencesById() {
+        return this.baseInstantiation.internal.referencesById;
+    }
+    get references() {
+        return this.baseInstantiation.internal.references;
+    }
+}
+export const writeUnsatisfiedParameterConstraintMessage = (name, constraint, arg) => `${name} must be assignable to ${constraint} (was ${arg})`;

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

@@ -0,0 +1,47 @@
+export * from "./config.ts";
+export * from "./constraint.ts";
+export * from "./generic.ts";
+export * from "./intrinsic.ts";
+export * from "./kinds.ts";
+export * from "./module.ts";
+export * from "./node.ts";
+export * from "./parse.ts";
+export * from "./predicate.ts";
+export * from "./refinements/after.ts";
+export * from "./refinements/before.ts";
+export * from "./refinements/divisor.ts";
+export * from "./refinements/exactLength.ts";
+export * from "./refinements/kinds.ts";
+export * from "./refinements/max.ts";
+export * from "./refinements/maxLength.ts";
+export * from "./refinements/min.ts";
+export * from "./refinements/minLength.ts";
+export * from "./refinements/pattern.ts";
+export * from "./refinements/range.ts";
+export * from "./roots/domain.ts";
+export * from "./roots/intersection.ts";
+export * from "./roots/morph.ts";
+export * from "./roots/proto.ts";
+export * from "./roots/root.ts";
+export * from "./roots/union.ts";
+export * from "./roots/unit.ts";
+export * from "./scope.ts";
+export * from "./shared/compile.ts";
+export * from "./shared/declare.ts";
+export * from "./shared/disjoint.ts";
+export * from "./shared/errors.ts";
+export * from "./shared/implement.ts";
+export * from "./shared/intersections.ts";
+export * from "./shared/jsonSchema.ts";
+export * from "./shared/registry.ts";
+export * from "./shared/standardSchema.ts";
+export * from "./shared/toJsonSchema.ts";
+export * from "./shared/traversal.ts";
+export * from "./shared/utils.ts";
+export * from "./structure/index.ts";
+export * from "./structure/optional.ts";
+export * from "./structure/prop.ts";
+export * from "./structure/required.ts";
+export * from "./structure/sequence.ts";
+export * from "./structure/structure.ts";
+export { ParseError } from "@ark/util";

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

@@ -0,0 +1,47 @@
+export * from "./config.js";
+export * from "./constraint.js";
+export * from "./generic.js";
+export * from "./intrinsic.js";
+export * from "./kinds.js";
+export * from "./module.js";
+export * from "./node.js";
+export * from "./parse.js";
+export * from "./predicate.js";
+export * from "./refinements/after.js";
+export * from "./refinements/before.js";
+export * from "./refinements/divisor.js";
+export * from "./refinements/exactLength.js";
+export * from "./refinements/kinds.js";
+export * from "./refinements/max.js";
+export * from "./refinements/maxLength.js";
+export * from "./refinements/min.js";
+export * from "./refinements/minLength.js";
+export * from "./refinements/pattern.js";
+export * from "./refinements/range.js";
+export * from "./roots/domain.js";
+export * from "./roots/intersection.js";
+export * from "./roots/morph.js";
+export * from "./roots/proto.js";
+export * from "./roots/root.js";
+export * from "./roots/union.js";
+export * from "./roots/unit.js";
+export * from "./scope.js";
+export * from "./shared/compile.js";
+export * from "./shared/declare.js";
+export * from "./shared/disjoint.js";
+export * from "./shared/errors.js";
+export * from "./shared/implement.js";
+export * from "./shared/intersections.js";
+export * from "./shared/jsonSchema.js";
+export * from "./shared/registry.js";
+export * from "./shared/standardSchema.js";
+export * from "./shared/toJsonSchema.js";
+export * from "./shared/traversal.js";
+export * from "./shared/utils.js";
+export * from "./structure/index.js";
+export * from "./structure/optional.js";
+export * from "./structure/prop.js";
+export * from "./structure/required.js";
+export * from "./structure/sequence.js";
+export * from "./structure/structure.js";
+export { ParseError } from "@ark/util";

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

@@ -0,0 +1,24 @@
+export declare const intrinsic: {
+    emptyStructure: import("./index.ts").StructureNode;
+    jsonPrimitive: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    jsonObject: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    jsonData: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    integer: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    lengthBoundable: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    key: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    nonNegativeIntegerString: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    string: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    number: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    bigint: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    boolean: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    symbol: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    undefined: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    object: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    null: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    Array: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    Date: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    false: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    never: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    true: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+    unknown: import("./index.ts").BaseRoot<import("./index.ts").InternalRootDeclaration>;
+};