@blade-hq/agent-client 1.1.1 → 1.1.2

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

@@ -0,0 +1,145 @@
+import { inferred, type array } from "@ark/util";
+import { type Constraint } from "../constraint.ts";
+import type { NodeSchema, nodeOfKind, reducibleKindOf } from "../kinds.ts";
+import { BaseNode, type GettableKeyOrNode, type KeyOrKeyNode, type NodeSelector } from "../node.ts";
+import type { Predicate } from "../predicate.ts";
+import type { Divisor } from "../refinements/divisor.ts";
+import type { ExactLength } from "../refinements/exactLength.ts";
+import type { Pattern } from "../refinements/pattern.ts";
+import type { ExclusiveDateRangeSchema, ExclusiveNumericRangeSchema, InclusiveDateRangeSchema, InclusiveNumericRangeSchema, LimitSchemaValue, UnknownRangeSchema } from "../refinements/range.ts";
+import type { BaseScope } from "../scope.ts";
+import type { BaseNodeDeclaration, TypeMeta } from "../shared/declare.ts";
+import { Disjoint } from "../shared/disjoint.ts";
+import { type NodeKind, type RootKind, type UnknownAttachments, type kindRightOf } from "../shared/implement.ts";
+import type { JsonSchema } from "../shared/jsonSchema.ts";
+import type { StandardJSONSchemaV1, StandardSchemaV1 } from "../shared/standardSchema.ts";
+import type { ToJsonSchema } from "../shared/toJsonSchema.ts";
+import { arkKind } from "../shared/utils.ts";
+import type { Prop } from "../structure/prop.ts";
+import type { PropFlatMapper, UndeclaredKeyBehavior } from "../structure/structure.ts";
+import type { Morph } from "./morph.ts";
+import type { Union } from "./union.ts";
+export interface InternalRootDeclaration extends BaseNodeDeclaration {
+    kind: RootKind;
+}
+export declare abstract class BaseRoot<
+/** @ts-ignore cast variance */
+out d extends InternalRootDeclaration = InternalRootDeclaration> extends BaseNode<d> implements StandardSchemaV1, StandardJSONSchemaV1 {
+    readonly [arkKind]: "root";
+    readonly [inferred]: unknown;
+    constructor(attachments: UnknownAttachments, $: BaseScope);
+    get rawIn(): BaseRoot;
+    get rawOut(): BaseRoot;
+    get internal(): this;
+    get "~standard"(): StandardSchemaV1.ArkTypeProps;
+    as(): this;
+    brand(name: string): this;
+    readonly(): this;
+    readonly branches: readonly nodeOfKind<Union.ChildKind>[];
+    distribute<mapOut, reduceOut = mapOut[]>(mapBranch: (branch: nodeOfKind<Union.ChildKind>, i: number, branches: array<nodeOfKind<Union.ChildKind>>) => mapOut, reduceMapped?: (mappedBranches: mapOut[]) => reduceOut): reduceOut;
+    abstract get defaultShortDescription(): string;
+    get shortDescription(): string;
+    toJsonSchema(opts?: ToJsonSchema.Options): JsonSchema;
+    toJsonSchemaRecurse(ctx: ToJsonSchema.Context): JsonSchema;
+    get alwaysExpandJsonSchema(): boolean;
+    protected toResolvedJsonSchema(ctx: ToJsonSchema.Context): JsonSchema;
+    protected abstract innerToJsonSchema(ctx: ToJsonSchema.Context): JsonSchema;
+    intersect(r: unknown): BaseRoot | Disjoint;
+    rawIntersect(r: BaseRoot): BaseRoot;
+    toNeverIfDisjoint(): BaseRoot;
+    and(r: unknown): BaseRoot;
+    rawAnd(r: BaseRoot): BaseRoot;
+    or(r: unknown): BaseRoot;
+    rawOr(r: BaseRoot): BaseRoot;
+    map(flatMapEntry: PropFlatMapper): BaseRoot;
+    pick(...keys: KeyOrKeyNode[]): BaseRoot;
+    omit(...keys: KeyOrKeyNode[]): BaseRoot;
+    required(): BaseRoot;
+    partial(): BaseRoot;
+    private _keyof?;
+    keyof(): BaseRoot;
+    get props(): Prop.Node[];
+    merge(r: unknown): BaseRoot;
+    private applyStructuralOperation;
+    get(...path: GettableKeyOrNode[]): BaseRoot;
+    extract(r: unknown): BaseRoot;
+    exclude(r: unknown): BaseRoot;
+    array(): BaseRoot;
+    overlaps(r: unknown): boolean;
+    extends(r: unknown): boolean;
+    ifExtends(r: unknown): BaseRoot | undefined;
+    subsumes(r: unknown): boolean;
+    configure(meta: TypeMeta.MappableInput, selector?: NodeSelector): this;
+    describe(description: string, selector?: NodeSelector): this;
+    optional(): [this, "?"];
+    default(thunkableValue: unknown): [this, "=", unknown];
+    from(input: unknown): unknown;
+    protected _pipe(...morphs: Morph[]): BaseRoot;
+    protected tryPipe(...morphs: Morph[]): BaseRoot;
+    pipe: ((...morphs: Morph[]) => BaseRoot) & {
+        try: (...morphs: Morph[]) => BaseRoot;
+    };
+    to(def: unknown): BaseRoot;
+    private toNode;
+    rawPipeOnce(morph: Morph): BaseRoot;
+    narrow(predicate: Predicate): BaseRoot;
+    constrain<kind extends Constraint.PrimitiveKind>(kind: kind, schema: NodeSchema<kind>): BaseRoot;
+    constrainIn<kind extends Constraint.PrimitiveKind>(kind: kind, schema: NodeSchema<kind>): BaseRoot;
+    constrainOut<kind extends Constraint.PrimitiveKind>(kind: kind, schema: NodeSchema<kind>): BaseRoot;
+    private _constrain;
+    onUndeclaredKey(cfg: UndeclaredKeyBehavior | UndeclaredKeyConfig): BaseRoot;
+    hasEqualMorphs(r: BaseRoot): boolean;
+    onDeepUndeclaredKey(behavior: UndeclaredKeyBehavior): BaseRoot;
+    filter(predicate: Predicate): BaseRoot;
+    divisibleBy(schema: Divisor.Schema): BaseRoot;
+    matching(schema: Pattern.Schema): BaseRoot;
+    atLeast(schema: InclusiveNumericRangeSchema): BaseRoot;
+    atMost(schema: InclusiveNumericRangeSchema): BaseRoot;
+    moreThan(schema: ExclusiveNumericRangeSchema): BaseRoot;
+    lessThan(schema: ExclusiveNumericRangeSchema): BaseRoot;
+    atLeastLength(schema: InclusiveNumericRangeSchema): BaseRoot;
+    atMostLength(schema: InclusiveNumericRangeSchema): BaseRoot;
+    moreThanLength(schema: ExclusiveNumericRangeSchema): BaseRoot;
+    lessThanLength(schema: ExclusiveNumericRangeSchema): BaseRoot;
+    exactlyLength(schema: ExactLength.Schema): BaseRoot;
+    atOrAfter(schema: InclusiveDateRangeSchema): BaseRoot;
+    atOrBefore(schema: InclusiveDateRangeSchema): BaseRoot;
+    laterThan(schema: ExclusiveDateRangeSchema): BaseRoot;
+    earlierThan(schema: ExclusiveDateRangeSchema): BaseRoot;
+}
+export type UndeclaredKeyConfig = {
+    rule: UndeclaredKeyBehavior;
+    deep?: boolean;
+};
+export declare const emptyBrandNameMessage = "Expected a non-empty brand name after #";
+export type emptyBrandNameMessage = typeof emptyBrandNameMessage;
+export declare const writeInvalidJsonSchemaTargetMessage: (target: string) => string;
+export declare const exclusivizeRangeSchema: <schema extends UnknownRangeSchema>(schema: schema) => schema;
+export type exclusivizeRangeSchema<schema extends UnknownRangeSchema> = schema extends LimitSchemaValue ? {
+    rule: schema;
+    exclusive: true;
+} : schema;
+export declare const typeOrTermExtends: (t: unknown, base: unknown) => boolean;
+export type intersectRoot<l extends RootKind, r extends NodeKind> = [
+    l,
+    r
+] extends [r, l] ? l : asymmetricIntersectionOf<l, r> | asymmetricIntersectionOf<r, l>;
+type asymmetricIntersectionOf<l extends NodeKind, r extends NodeKind> = l extends unknown ? r extends kindRightOf<l> ? l | reducibleKindOf<l> : never : never;
+export type schemaKindRightOf<kind extends RootKind> = Extract<kindRightOf<kind>, RootKind>;
+export type schemaKindOrRightOf<kind extends RootKind> = kind | schemaKindRightOf<kind>;
+export type StructuralOperationBranchResultByName = {
+    keyof: Union.ChildNode;
+    pick: Union.ChildNode;
+    omit: Union.ChildNode;
+    get: Union.ChildNode;
+    map: Union.ChildNode;
+    required: Union.ChildNode;
+    partial: Union.ChildNode;
+    merge: Union.ChildNode;
+    props: array<Prop.Node>;
+};
+export type StructuralOperationName = keyof StructuralOperationBranchResultByName;
+export declare const writeLiteralUnionEntriesMessage: (expression: string) => string;
+export declare const writeNonStructuralOperandMessage: <operation extends StructuralOperationName, operand extends string>(operation: operation, operand: operand) => writeNonStructuralOperandMessage<operation, operand>;
+export type writeNonStructuralOperandMessage<operation extends StructuralOperationName, operand extends string> = `${operation} operand must be an object (was ${operand})`;
+export {};

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

@@ -0,0 +1,455 @@
+import { arrayEquals, flatMorph, includes, inferred, omit, throwInternalError, throwParseError } from "@ark/util";
+import { mergeToJsonSchemaConfigs } from "../config.js";
+import { throwInvalidOperandError } from "../constraint.js";
+import { BaseNode } from "../node.js";
+import { Disjoint, writeUnsatisfiableExpressionError } from "../shared/disjoint.js";
+import { ArkErrors } from "../shared/errors.js";
+import { structuralKinds } from "../shared/implement.js";
+import { intersectNodesRoot, pipeNodesRoot } from "../shared/intersections.js";
+import { $ark } from "../shared/registry.js";
+import { arkKind, hasArkKind } from "../shared/utils.js";
+import { assertDefaultValueAssignability } from "../structure/optional.js";
+export class BaseRoot extends BaseNode {
+    constructor(attachments, $) {
+        super(attachments, $);
+        // define as a getter to avoid it being enumerable/spreadable
+        Object.defineProperty(this, arkKind, { value: "root", enumerable: false });
+    }
+    // doesn't seem possible to override this at a type-level (e.g. via declare)
+    // without TS complaining about getters
+    get rawIn() {
+        return super.rawIn;
+    }
+    get rawOut() {
+        return super.rawOut;
+    }
+    get internal() {
+        return this;
+    }
+    get "~standard"() {
+        return {
+            vendor: "arktype",
+            version: 1,
+            validate: input => {
+                const out = this(input);
+                if (out instanceof ArkErrors)
+                    return out;
+                return { value: out };
+            },
+            jsonSchema: {
+                input: opts => this.rawIn.toJsonSchema({
+                    target: validateStandardJsonSchemaTarget(opts.target),
+                    ...opts.libraryOptions
+                }),
+                output: opts => this.rawOut.toJsonSchema({
+                    target: validateStandardJsonSchemaTarget(opts.target),
+                    ...opts.libraryOptions
+                })
+            }
+        };
+    }
+    as() {
+        return this;
+    }
+    brand(name) {
+        if (name === "")
+            return throwParseError(emptyBrandNameMessage);
+        return this;
+    }
+    readonly() {
+        return this;
+    }
+    branches = this.hasKind("union") ? this.inner.branches : [this];
+    distribute(mapBranch, reduceMapped) {
+        const mappedBranches = this.branches.map(mapBranch);
+        return reduceMapped?.(mappedBranches) ?? mappedBranches;
+    }
+    get shortDescription() {
+        return this.meta.description ?? this.defaultShortDescription;
+    }
+    toJsonSchema(opts = {}) {
+        const ctx = mergeToJsonSchemaConfigs(this.$.resolvedConfig.toJsonSchema, opts);
+        ctx.useRefs ||= this.isCyclic;
+        // ensure $schema is the first key if present
+        const schema = typeof ctx.dialect === "string" ? { $schema: ctx.dialect } : {};
+        Object.assign(schema, this.toJsonSchemaRecurse(ctx));
+        if (ctx.useRefs) {
+            const defs = flatMorph(this.references, (i, ref) => ref.isRoot() && !ref.alwaysExpandJsonSchema ?
+                [ref.id, ref.toResolvedJsonSchema(ctx)]
+                : []);
+            // draft-2020-12 uses $defs, draft-07 uses definitions
+            if (ctx.target === "draft-07")
+                Object.assign(schema, { definitions: defs });
+            else
+                schema.$defs = defs;
+        }
+        return schema;
+    }
+    toJsonSchemaRecurse(ctx) {
+        if (ctx.useRefs && !this.alwaysExpandJsonSchema) {
+            // draft-2020-12 uses $defs, draft-07 uses definitions
+            const defsKey = ctx.target === "draft-07" ? "definitions" : "$defs";
+            return { $ref: `#/${defsKey}/${this.id}` };
+        }
+        return this.toResolvedJsonSchema(ctx);
+    }
+    get alwaysExpandJsonSchema() {
+        return (this.isBasis() ||
+            this.kind === "alias" ||
+            (this.hasKind("union") && this.isBoolean));
+    }
+    toResolvedJsonSchema(ctx) {
+        const result = this.innerToJsonSchema(ctx);
+        return Object.assign(result, this.metaJson);
+    }
+    intersect(r) {
+        const rNode = this.$.parseDefinition(r);
+        const result = this.rawIntersect(rNode);
+        if (result instanceof Disjoint)
+            return result;
+        return this.$.finalize(result);
+    }
+    rawIntersect(r) {
+        return intersectNodesRoot(this, r, this.$);
+    }
+    toNeverIfDisjoint() {
+        return this;
+    }
+    and(r) {
+        const result = this.intersect(r);
+        return result instanceof Disjoint ? result.throw() : result;
+    }
+    rawAnd(r) {
+        const result = this.rawIntersect(r);
+        return result instanceof Disjoint ? result.throw() : result;
+    }
+    or(r) {
+        const rNode = this.$.parseDefinition(r);
+        return this.$.finalize(this.rawOr(rNode));
+    }
+    rawOr(r) {
+        const branches = [...this.branches, ...r.branches];
+        return this.$.node("union", branches);
+    }
+    map(flatMapEntry) {
+        return this.$.schema(this.applyStructuralOperation("map", [flatMapEntry]));
+    }
+    pick(...keys) {
+        return this.$.schema(this.applyStructuralOperation("pick", keys));
+    }
+    omit(...keys) {
+        return this.$.schema(this.applyStructuralOperation("omit", keys));
+    }
+    required() {
+        return this.$.schema(this.applyStructuralOperation("required", []));
+    }
+    partial() {
+        return this.$.schema(this.applyStructuralOperation("partial", []));
+    }
+    _keyof;
+    keyof() {
+        if (this._keyof)
+            return this._keyof;
+        const result = this.applyStructuralOperation("keyof", []).reduce((result, branch) => result.intersect(branch).toNeverIfDisjoint(), $ark.intrinsic.unknown.internal);
+        if (result.branches.length === 0) {
+            throwParseError(writeUnsatisfiableExpressionError(`keyof ${this.expression}`));
+        }
+        return (this._keyof = this.$.finalize(result));
+    }
+    get props() {
+        if (this.branches.length !== 1)
+            return throwParseError(writeLiteralUnionEntriesMessage(this.expression));
+        return [...this.applyStructuralOperation("props", [])[0]];
+    }
+    merge(r) {
+        const rNode = this.$.parseDefinition(r);
+        return this.$.schema(rNode.distribute(branch => this.applyStructuralOperation("merge", [
+            structureOf(branch) ??
+                throwParseError(writeNonStructuralOperandMessage("merge", branch.expression))
+        ])));
+    }
+    applyStructuralOperation(operation, args) {
+        return this.distribute(branch => {
+            if (branch.equals($ark.intrinsic.object) && operation !== "merge")
+                // ideally this wouldn't be a special case, but for now it
+                // allows us to bypass `assertHasKeys` checks on base
+                // instantiations of generics like Pick and Omit. Could
+                // potentially be removed once constraints can reference each other:
+                // https://github.com/arktypeio/arktype/issues/1053
+                return branch;
+            const structure = structureOf(branch);
+            if (!structure) {
+                throwParseError(writeNonStructuralOperandMessage(operation, branch.expression));
+            }
+            if (operation === "keyof")
+                return structure.keyof();
+            if (operation === "get")
+                return structure.get(...args);
+            if (operation === "props")
+                return structure.props;
+            const structuralMethodName = operation === "required" ? "require"
+                : operation === "partial" ? "optionalize"
+                    : operation;
+            return this.$.node("intersection", {
+                domain: "object",
+                structure: structure[structuralMethodName](...args)
+            });
+        });
+    }
+    get(...path) {
+        if (path[0] === undefined)
+            return this;
+        return this.$.schema(this.applyStructuralOperation("get", path));
+    }
+    extract(r) {
+        const rNode = this.$.parseDefinition(r);
+        return this.$.schema(this.branches.filter(branch => branch.extends(rNode)));
+    }
+    exclude(r) {
+        const rNode = this.$.parseDefinition(r);
+        return this.$.schema(this.branches.filter(branch => !branch.extends(rNode)));
+    }
+    array() {
+        return this.$.schema(this.isUnknown() ?
+            { proto: Array }
+            : {
+                proto: Array,
+                sequence: this
+            }, { prereduced: true });
+    }
+    overlaps(r) {
+        const intersection = this.intersect(r);
+        return !(intersection instanceof Disjoint);
+    }
+    extends(r) {
+        if (this.isNever())
+            return true;
+        const intersection = this.intersect(r);
+        return (!(intersection instanceof Disjoint) && this.equals(intersection));
+    }
+    ifExtends(r) {
+        return this.extends(r) ? this : undefined;
+    }
+    subsumes(r) {
+        const rNode = this.$.parseDefinition(r);
+        return rNode.extends(this);
+    }
+    configure(meta, selector = "shallow") {
+        return this.configureReferences(meta, selector);
+    }
+    describe(description, selector = "shallow") {
+        return this.configure({ description }, selector);
+    }
+    // these should ideally be implemented in arktype since they use its syntax
+    // https://github.com/arktypeio/arktype/issues/1223
+    optional() {
+        return [this, "?"];
+    }
+    // these should ideally be implemented in arktype since they use its syntax
+    // https://github.com/arktypeio/arktype/issues/1223
+    default(thunkableValue) {
+        assertDefaultValueAssignability(this, thunkableValue, null);
+        return [this, "=", thunkableValue];
+    }
+    from(input) {
+        // ideally we might not validate here but for now we need to do determine
+        // which morphs to apply
+        return this.assert(input);
+    }
+    _pipe(...morphs) {
+        const result = morphs.reduce((acc, morph) => acc.rawPipeOnce(morph), this);
+        return this.$.finalize(result);
+    }
+    tryPipe(...morphs) {
+        const result = morphs.reduce((acc, morph) => acc.rawPipeOnce(hasArkKind(morph, "root") ? morph : ((In, ctx) => {
+            try {
+                return morph(In, ctx);
+            }
+            catch (e) {
+                return ctx.error({
+                    code: "predicate",
+                    predicate: morph,
+                    actual: `aborted due to error:\n    ${e}\n`
+                });
+            }
+        })), this);
+        return this.$.finalize(result);
+    }
+    pipe = Object.assign(this._pipe.bind(this), {
+        try: this.tryPipe.bind(this)
+    });
+    to(def) {
+        return this.$.finalize(this.toNode(this.$.parseDefinition(def)));
+    }
+    toNode(root) {
+        const result = pipeNodesRoot(this, root, this.$);
+        if (result instanceof Disjoint)
+            return result.throw();
+        return result;
+    }
+    rawPipeOnce(morph) {
+        if (hasArkKind(morph, "root"))
+            return this.toNode(morph);
+        return this.distribute(branch => branch.hasKind("morph") ?
+            this.$.node("morph", {
+                in: branch.inner.in,
+                morphs: [...branch.morphs, morph]
+            })
+            : this.$.node("morph", {
+                in: branch,
+                morphs: [morph]
+            }), this.$.parseSchema);
+    }
+    narrow(predicate) {
+        return this.constrainOut("predicate", predicate);
+    }
+    constrain(kind, schema) {
+        return this._constrain("root", kind, schema);
+    }
+    constrainIn(kind, schema) {
+        return this._constrain("in", kind, schema);
+    }
+    constrainOut(kind, schema) {
+        return this._constrain("out", kind, schema);
+    }
+    _constrain(io, kind, schema) {
+        const constraint = this.$.node(kind, schema);
+        if (constraint.isRoot()) {
+            // if the node reduces to `unknown`, nothing to do (e.g. minLength: 0)
+            return constraint.isUnknown() ? this : (throwInternalError(`Unexpected constraint node ${constraint}`));
+        }
+        const operand = io === "root" ? this
+            : io === "in" ? this.rawIn
+                : this.rawOut;
+        if (operand.hasKind("morph") ||
+            (constraint.impliedBasis && !operand.extends(constraint.impliedBasis))) {
+            return throwInvalidOperandError(kind, constraint.impliedBasis, this);
+        }
+        const partialIntersection = this.$.node("intersection", {
+            // important this is constraint.kind instead of kind in case
+            // the node was reduced during parsing
+            [constraint.kind]: constraint
+        });
+        const result = io === "out" ?
+            pipeNodesRoot(this, partialIntersection, this.$)
+            : intersectNodesRoot(this, partialIntersection, this.$);
+        if (result instanceof Disjoint)
+            result.throw();
+        return this.$.finalize(result);
+    }
+    onUndeclaredKey(cfg) {
+        const rule = typeof cfg === "string" ? cfg : cfg.rule;
+        const deep = typeof cfg === "string" ? false : cfg.deep;
+        return this.$.finalize(this.transform((kind, inner) => kind === "structure" ?
+            rule === "ignore" ?
+                omit(inner, { undeclared: 1 })
+                : { ...inner, undeclared: rule }
+            : inner, deep ? undefined : ({ shouldTransform: node => !includes(structuralKinds, node.kind) })));
+    }
+    hasEqualMorphs(r) {
+        if (!this.includesTransform && !r.includesTransform)
+            return true;
+        if (!arrayEquals(this.shallowMorphs, r.shallowMorphs))
+            return false;
+        if (!arrayEquals(this.flatMorphs, r.flatMorphs, {
+            isEqual: (l, r) => l.propString === r.propString &&
+                (l.node.hasKind("morph") && r.node.hasKind("morph") ?
+                    l.node.hasEqualMorphs(r.node)
+                    : l.node.hasKind("intersection") && r.node.hasKind("intersection") ?
+                        l.node.structure?.structuralMorphRef ===
+                            r.node.structure?.structuralMorphRef
+                        : false)
+        }))
+            return false;
+        return true;
+    }
+    onDeepUndeclaredKey(behavior) {
+        return this.onUndeclaredKey({ rule: behavior, deep: true });
+    }
+    filter(predicate) {
+        return this.constrainIn("predicate", predicate);
+    }
+    divisibleBy(schema) {
+        return this.constrain("divisor", schema);
+    }
+    matching(schema) {
+        return this.constrain("pattern", schema);
+    }
+    atLeast(schema) {
+        return this.constrain("min", schema);
+    }
+    atMost(schema) {
+        return this.constrain("max", schema);
+    }
+    moreThan(schema) {
+        return this.constrain("min", exclusivizeRangeSchema(schema));
+    }
+    lessThan(schema) {
+        return this.constrain("max", exclusivizeRangeSchema(schema));
+    }
+    atLeastLength(schema) {
+        return this.constrain("minLength", schema);
+    }
+    atMostLength(schema) {
+        return this.constrain("maxLength", schema);
+    }
+    moreThanLength(schema) {
+        return this.constrain("minLength", exclusivizeRangeSchema(schema));
+    }
+    lessThanLength(schema) {
+        return this.constrain("maxLength", exclusivizeRangeSchema(schema));
+    }
+    exactlyLength(schema) {
+        return this.constrain("exactLength", schema);
+    }
+    atOrAfter(schema) {
+        return this.constrain("after", schema);
+    }
+    atOrBefore(schema) {
+        return this.constrain("before", schema);
+    }
+    laterThan(schema) {
+        return this.constrain("after", exclusivizeRangeSchema(schema));
+    }
+    earlierThan(schema) {
+        return this.constrain("before", exclusivizeRangeSchema(schema));
+    }
+}
+export const emptyBrandNameMessage = `Expected a non-empty brand name after #`;
+const supportedJsonSchemaTargets = [
+    "draft-2020-12",
+    "draft-07"
+];
+export const writeInvalidJsonSchemaTargetMessage = (target) => `JSONSchema target '${target}' is not supported (must be ${supportedJsonSchemaTargets.map(t => `"${t}"`).join(" or ")})`;
+const validateStandardJsonSchemaTarget = (target) => {
+    if (!includes(supportedJsonSchemaTargets, target))
+        throwParseError(writeInvalidJsonSchemaTargetMessage(target));
+    return target;
+};
+export const exclusivizeRangeSchema = (schema) => (typeof schema === "object" && !(schema instanceof Date) ?
+    { ...schema, exclusive: true }
+    : {
+        rule: schema,
+        exclusive: true
+    });
+export const typeOrTermExtends = (t, base) => hasArkKind(base, "root") ?
+    hasArkKind(t, "root") ? t.extends(base)
+        : base.allows(t)
+    : hasArkKind(t, "root") ? t.hasUnit(base)
+        : base === t;
+const structureOf = (branch) => {
+    if (branch.hasKind("morph"))
+        return null;
+    if (branch.hasKind("intersection")) {
+        return (branch.inner.structure ??
+            (branch.basis?.domain === "object" ?
+                branch.$.bindReference($ark.intrinsic.emptyStructure)
+                : null));
+    }
+    if (branch.isBasis() && branch.domain === "object")
+        return branch.$.bindReference($ark.intrinsic.emptyStructure);
+    return null;
+};
+export const writeLiteralUnionEntriesMessage = (expression) => `Props cannot be extracted from a union. Use .distribute to extract props from each branch instead. Received:
+${expression}`;
+export const writeNonStructuralOperandMessage = (operation, operand) => `${operation} operand must be an object (was ${operand})`;