@blade-hq/agent-client 1.1.1 → 1.1.2

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

@@ -0,0 +1,292 @@
+import { flatMorph, hasDomain, includes, isEmptyObject, isKeyOf, throwParseError } from "@ark/util";
+import { constraintKeyParser, flattenConstraints, intersectConstraints } from "../constraint.js";
+import { Disjoint } from "../shared/disjoint.js";
+import { implementNode, prestructuralKinds, structureKeys } from "../shared/implement.js";
+import { intersectOrPipeNodes } from "../shared/intersections.js";
+import { hasArkKind, isNode } from "../shared/utils.js";
+import { BaseRoot } from "./root.js";
+import { defineRightwardIntersections } from "./utils.js";
+const implementation = implementNode({
+    kind: "intersection",
+    hasAssociatedError: true,
+    normalize: rawSchema => {
+        if (isNode(rawSchema))
+            return rawSchema;
+        const { structure, ...schema } = rawSchema;
+        const hasRootStructureKey = !!structure;
+        const normalizedStructure = structure ?? {};
+        const normalized = flatMorph(schema, (k, v) => {
+            if (isKeyOf(k, structureKeys)) {
+                if (hasRootStructureKey) {
+                    throwParseError(`Flattened structure key ${k} cannot be specified alongside a root 'structure' key.`);
+                }
+                normalizedStructure[k] = v;
+                return [];
+            }
+            return [k, v];
+        });
+        if (hasArkKind(normalizedStructure, "constraint") ||
+            !isEmptyObject(normalizedStructure))
+            normalized.structure = normalizedStructure;
+        return normalized;
+    },
+    finalizeInnerJson: ({ structure, ...rest }) => hasDomain(structure, "object") ? { ...structure, ...rest } : rest,
+    keys: {
+        domain: {
+            child: true,
+            parse: (schema, ctx) => ctx.$.node("domain", schema)
+        },
+        proto: {
+            child: true,
+            parse: (schema, ctx) => ctx.$.node("proto", schema)
+        },
+        structure: {
+            child: true,
+            parse: (schema, ctx) => ctx.$.node("structure", schema),
+            serialize: node => {
+                if (!node.sequence?.minLength)
+                    return node.collapsibleJson;
+                const { sequence, ...structureJson } = node.collapsibleJson;
+                const { minVariadicLength, ...sequenceJson } = sequence;
+                const collapsibleSequenceJson = sequenceJson.variadic && Object.keys(sequenceJson).length === 1 ?
+                    sequenceJson.variadic
+                    : sequenceJson;
+                return { ...structureJson, sequence: collapsibleSequenceJson };
+            }
+        },
+        divisor: {
+            child: true,
+            parse: constraintKeyParser("divisor")
+        },
+        max: {
+            child: true,
+            parse: constraintKeyParser("max")
+        },
+        min: {
+            child: true,
+            parse: constraintKeyParser("min")
+        },
+        maxLength: {
+            child: true,
+            parse: constraintKeyParser("maxLength")
+        },
+        minLength: {
+            child: true,
+            parse: constraintKeyParser("minLength")
+        },
+        exactLength: {
+            child: true,
+            parse: constraintKeyParser("exactLength")
+        },
+        before: {
+            child: true,
+            parse: constraintKeyParser("before")
+        },
+        after: {
+            child: true,
+            parse: constraintKeyParser("after")
+        },
+        pattern: {
+            child: true,
+            parse: constraintKeyParser("pattern")
+        },
+        predicate: {
+            child: true,
+            parse: constraintKeyParser("predicate")
+        }
+    },
+    // leverage reduction logic from intersection and identity to ensure initial
+    // parse result is reduced
+    reduce: (inner, $) => 
+    // we cast union out of the result here since that only occurs when intersecting two sequences
+    // that cannot occur when reducing a single intersection schema using unknown
+    intersectIntersections({}, inner, {
+        $,
+        invert: false,
+        pipe: false
+    }),
+    defaults: {
+        description: node => {
+            if (node.children.length === 0)
+                return "unknown";
+            if (node.structure)
+                return node.structure.description;
+            const childDescriptions = [];
+            if (node.basis &&
+                !node.prestructurals.some(r => r.impl.obviatesBasisDescription))
+                childDescriptions.push(node.basis.description);
+            if (node.prestructurals.length) {
+                const sortedRefinementDescriptions = node.prestructurals
+                    .slice()
+                    // override alphabetization to describe min before max
+                    .sort((l, r) => (l.kind === "min" && r.kind === "max" ? -1 : 0))
+                    .map(r => r.description);
+                childDescriptions.push(...sortedRefinementDescriptions);
+            }
+            if (node.inner.predicate) {
+                childDescriptions.push(...node.inner.predicate.map(p => p.description));
+            }
+            return childDescriptions.join(" and ");
+        },
+        expected: source => `  ◦ ${source.errors.map(e => e.expected).join("\n  ◦ ")}`,
+        problem: ctx => `(${ctx.actual}) must be...\n${ctx.expected}`
+    },
+    intersections: {
+        intersection: (l, r, ctx) => intersectIntersections(l.inner, r.inner, ctx),
+        ...defineRightwardIntersections("intersection", (l, r, ctx) => {
+            // if l is unknown, return r
+            if (l.children.length === 0)
+                return r;
+            const { domain, proto, ...lInnerConstraints } = l.inner;
+            const lBasis = proto ?? domain;
+            const basis = lBasis ? intersectOrPipeNodes(lBasis, r, ctx) : r;
+            return (basis instanceof Disjoint ? basis
+                : l?.basis?.equals(basis) ?
+                    // if the basis doesn't change, return the original intesection
+                    l
+                    // given we've already precluded l being unknown, the result must
+                    // be an intersection with the new basis result integrated
+                    : l.$.node("intersection", { ...lInnerConstraints, [basis.kind]: basis }, { prereduced: true }));
+        })
+    }
+});
+export class IntersectionNode extends BaseRoot {
+    basis = this.inner.domain ?? this.inner.proto ?? null;
+    prestructurals = [];
+    refinements = this.children.filter((node) => {
+        if (!node.isRefinement())
+            return false;
+        if (includes(prestructuralKinds, node.kind))
+            // mutation is fine during initialization
+            this.prestructurals.push(node);
+        return true;
+    });
+    structure = this.inner.structure;
+    expression = writeIntersectionExpression(this);
+    get shallowMorphs() {
+        return this.inner.structure?.structuralMorph ?
+            [this.inner.structure.structuralMorph]
+            : [];
+    }
+    get defaultShortDescription() {
+        return this.basis?.defaultShortDescription ?? "present";
+    }
+    innerToJsonSchema(ctx) {
+        return this.children.reduce(
+        // cast is required since TS doesn't know children have compatible schema prerequisites
+        (schema, child) => child.isBasis() ?
+            child.toJsonSchemaRecurse(ctx)
+            : child.reduceJsonSchema(schema, ctx), {});
+    }
+    traverseAllows = (data, ctx) => this.children.every(child => child.traverseAllows(data, ctx));
+    traverseApply = (data, ctx) => {
+        const errorCount = ctx.currentErrorCount;
+        if (this.basis) {
+            this.basis.traverseApply(data, ctx);
+            if (ctx.currentErrorCount > errorCount)
+                return;
+        }
+        if (this.prestructurals.length) {
+            for (let i = 0; i < this.prestructurals.length - 1; i++) {
+                this.prestructurals[i].traverseApply(data, ctx);
+                if (ctx.failFast && ctx.currentErrorCount > errorCount)
+                    return;
+            }
+            this.prestructurals[this.prestructurals.length - 1].traverseApply(data, ctx);
+            if (ctx.currentErrorCount > errorCount)
+                return;
+        }
+        if (this.structure) {
+            this.structure.traverseApply(data, ctx);
+            if (ctx.currentErrorCount > errorCount)
+                return;
+        }
+        if (this.inner.predicate) {
+            for (let i = 0; i < this.inner.predicate.length - 1; i++) {
+                this.inner.predicate[i].traverseApply(data, ctx);
+                if (ctx.failFast && ctx.currentErrorCount > errorCount)
+                    return;
+            }
+            this.inner.predicate[this.inner.predicate.length - 1].traverseApply(data, ctx);
+        }
+    };
+    compile(js) {
+        if (js.traversalKind === "Allows") {
+            for (const child of this.children)
+                js.check(child);
+            js.return(true);
+            return;
+        }
+        js.initializeErrorCount();
+        if (this.basis) {
+            js.check(this.basis);
+            // we only have to return conditionally if this is not the last check
+            if (this.children.length > 1)
+                js.returnIfFail();
+        }
+        if (this.prestructurals.length) {
+            for (let i = 0; i < this.prestructurals.length - 1; i++) {
+                js.check(this.prestructurals[i]);
+                js.returnIfFailFast();
+            }
+            js.check(this.prestructurals[this.prestructurals.length - 1]);
+            if (this.structure || this.inner.predicate)
+                js.returnIfFail();
+        }
+        if (this.structure) {
+            js.check(this.structure);
+            if (this.inner.predicate)
+                js.returnIfFail();
+        }
+        if (this.inner.predicate) {
+            for (let i = 0; i < this.inner.predicate.length - 1; i++) {
+                js.check(this.inner.predicate[i]);
+                // since predicates can be chained, we have to fail immediately
+                // if one fails
+                js.returnIfFail();
+            }
+            js.check(this.inner.predicate[this.inner.predicate.length - 1]);
+        }
+    }
+}
+export const Intersection = {
+    implementation,
+    Node: IntersectionNode
+};
+const writeIntersectionExpression = (node) => {
+    if (node.structure?.expression)
+        return node.structure.expression;
+    const basisExpression = (node.basis &&
+        !node.prestructurals.some(n => n.impl.obviatesBasisExpression)) ?
+        node.basis.nestableExpression
+        : "";
+    const refinementsExpression = node.prestructurals
+        .map(n => n.expression)
+        .join(" & ");
+    const fullExpression = `${basisExpression}${basisExpression ? " " : ""}${refinementsExpression}`;
+    if (fullExpression === "Array == 0")
+        return "[]";
+    return fullExpression || "unknown";
+};
+const intersectIntersections = (l, r, ctx) => {
+    const baseInner = {};
+    const lBasis = l.proto ?? l.domain;
+    const rBasis = r.proto ?? r.domain;
+    const basisResult = lBasis ?
+        rBasis ?
+            intersectOrPipeNodes(lBasis, rBasis, ctx)
+            : lBasis
+        : rBasis;
+    if (basisResult instanceof Disjoint)
+        return basisResult;
+    if (basisResult)
+        baseInner[basisResult.kind] = basisResult;
+    return intersectConstraints({
+        kind: "intersection",
+        baseInner,
+        l: flattenConstraints(l),
+        r: flattenConstraints(r),
+        roots: [],
+        ctx
+    });
+};

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

@@ -0,0 +1,62 @@
+import { type array, type listable } from "@ark/util";
+import type { RootSchema } from "../kinds.ts";
+import type { NodeCompiler } from "../shared/compile.ts";
+import type { BaseNormalizedSchema, declareNode } from "../shared/declare.ts";
+import { type nodeImplementationOf, type RootKind } from "../shared/implement.ts";
+import type { JsonSchema } from "../shared/jsonSchema.ts";
+import type { ToJsonSchema } from "../shared/toJsonSchema.ts";
+import type { Traversal, TraverseAllows, TraverseApply } from "../shared/traversal.ts";
+import { BaseRoot } from "./root.ts";
+export declare namespace Morph {
+    interface Inner {
+        readonly in?: BaseRoot;
+        readonly morphs: array<Morph | BaseRoot>;
+        readonly declaredIn?: BaseRoot;
+        readonly declaredOut?: BaseRoot;
+    }
+    interface Schema extends BaseNormalizedSchema {
+        readonly in?: RootSchema;
+        readonly morphs: listable<Morph | BaseRoot>;
+        readonly declaredIn?: BaseRoot;
+        readonly declaredOut?: BaseRoot;
+    }
+    interface Declaration extends declareNode<{
+        kind: "morph";
+        schema: Schema;
+        normalizedSchema: Schema;
+        inner: Inner;
+        childKind: RootKind;
+    }> {
+    }
+    type Node = MorphNode;
+    type In<morph extends Morph> = morph extends Morph<infer i> ? i : never;
+    type Out<morph extends Morph> = morph extends Morph<never, infer o> ? o : never;
+    type ContextFree<i = never, o = unknown> = (In: i) => o;
+}
+export type Morph<i = never, o = unknown> = (In: i, ctx: Traversal) => o;
+export declare class MorphNode extends BaseRoot<Morph.Declaration> {
+    serializedMorphs: string[];
+    compiledMorphs: string;
+    lastMorph: Morph | BaseRoot | undefined;
+    lastMorphIfNode: BaseRoot | undefined;
+    introspectableIn: BaseRoot | undefined;
+    introspectableOut: BaseRoot | undefined;
+    get shallowMorphs(): array<Morph>;
+    get rawIn(): BaseRoot;
+    get rawOut(): BaseRoot;
+    declareIn(declaredIn: BaseRoot): MorphNode;
+    declareOut(declaredOut: BaseRoot): MorphNode;
+    expression: string;
+    get defaultShortDescription(): string;
+    protected innerToJsonSchema(ctx: ToJsonSchema.Context): JsonSchema;
+    compile(js: NodeCompiler): void;
+    traverseAllows: TraverseAllows;
+    traverseApply: TraverseApply;
+    /** Check if the morphs of r are equal to those of this node */
+    hasEqualMorphs(r: MorphNode): boolean;
+}
+export declare const Morph: {
+    implementation: nodeImplementationOf<Morph.Declaration>;
+    Node: typeof MorphNode;
+};
+export declare const writeMorphIntersectionMessage: (lDescription: string, rDescription: string) => string;

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

@@ -0,0 +1,159 @@
+import { arrayEquals, liftArray, throwParseError } from "@ark/util";
+import { Disjoint } from "../shared/disjoint.js";
+import { implementNode } from "../shared/implement.js";
+import { intersectOrPipeNodes } from "../shared/intersections.js";
+import { $ark, registeredReference } from "../shared/registry.js";
+import { hasArkKind } from "../shared/utils.js";
+import { BaseRoot } from "./root.js";
+import { defineRightwardIntersections } from "./utils.js";
+const implementation = implementNode({
+    kind: "morph",
+    hasAssociatedError: false,
+    keys: {
+        in: {
+            child: true,
+            parse: (schema, ctx) => ctx.$.parseSchema(schema)
+        },
+        morphs: {
+            parse: liftArray,
+            serialize: morphs => morphs.map(m => hasArkKind(m, "root") ? m.json : registeredReference(m))
+        },
+        declaredIn: {
+            child: false,
+            serialize: node => node.json
+        },
+        declaredOut: {
+            child: false,
+            serialize: node => node.json
+        }
+    },
+    normalize: schema => schema,
+    defaults: {
+        description: node => `a morph from ${node.rawIn.description} to ${node.rawOut?.description ?? "unknown"}`
+    },
+    intersections: {
+        morph: (l, r, ctx) => {
+            if (!l.hasEqualMorphs(r)) {
+                return throwParseError(writeMorphIntersectionMessage(l.expression, r.expression));
+            }
+            const inTersection = intersectOrPipeNodes(l.rawIn, r.rawIn, ctx);
+            if (inTersection instanceof Disjoint)
+                return inTersection;
+            const baseInner = {
+                morphs: l.morphs
+            };
+            if (l.declaredIn || r.declaredIn) {
+                const declaredIn = intersectOrPipeNodes(l.rawIn, r.rawIn, ctx);
+                // we can't treat this as a normal Disjoint since it's just declared
+                // it should only happen if someone's essentially trying to create a broken type
+                if (declaredIn instanceof Disjoint)
+                    return declaredIn.throw();
+                else
+                    baseInner.declaredIn = declaredIn;
+            }
+            if (l.declaredOut || r.declaredOut) {
+                const declaredOut = intersectOrPipeNodes(l.rawOut, r.rawOut, ctx);
+                if (declaredOut instanceof Disjoint)
+                    return declaredOut.throw();
+                else
+                    baseInner.declaredOut = declaredOut;
+            }
+            // in case from is a union, we need to distribute the branches
+            // to can be a union as any schema is allowed
+            return inTersection.distribute(inBranch => ctx.$.node("morph", {
+                ...baseInner,
+                in: inBranch
+            }), ctx.$.parseSchema);
+        },
+        ...defineRightwardIntersections("morph", (l, r, ctx) => {
+            const inTersection = l.inner.in ? intersectOrPipeNodes(l.inner.in, r, ctx) : r;
+            return (inTersection instanceof Disjoint ? inTersection
+                : inTersection.equals(l.inner.in) ? l
+                    : ctx.$.node("morph", {
+                        ...l.inner,
+                        in: inTersection
+                    }));
+        })
+    }
+});
+export class MorphNode extends BaseRoot {
+    serializedMorphs = this.morphs.map(registeredReference);
+    compiledMorphs = `[${this.serializedMorphs}]`;
+    lastMorph = this.inner.morphs[this.inner.morphs.length - 1];
+    lastMorphIfNode = hasArkKind(this.lastMorph, "root") ? this.lastMorph : undefined;
+    introspectableIn = this.inner.in;
+    introspectableOut = this.lastMorphIfNode ?
+        Object.assign(this.referencesById, this.lastMorphIfNode.referencesById) &&
+            this.lastMorphIfNode.rawOut
+        : undefined;
+    get shallowMorphs() {
+        // if the morph input is a union, it should not contain any other shallow morphs
+        return Array.isArray(this.inner.in?.shallowMorphs) ?
+            [...this.inner.in.shallowMorphs, ...this.morphs]
+            : this.morphs;
+    }
+    get rawIn() {
+        return (this.declaredIn ?? this.inner.in?.rawIn ?? $ark.intrinsic.unknown.internal);
+    }
+    get rawOut() {
+        return (this.declaredOut ??
+            this.introspectableOut ??
+            $ark.intrinsic.unknown.internal);
+    }
+    declareIn(declaredIn) {
+        return this.$.node("morph", {
+            ...this.inner,
+            declaredIn
+        });
+    }
+    declareOut(declaredOut) {
+        return this.$.node("morph", {
+            ...this.inner,
+            declaredOut
+        });
+    }
+    expression = `(In: ${this.rawIn.expression}) => ${this.lastMorphIfNode ? "To" : "Out"}<${this.rawOut.expression}>`;
+    get defaultShortDescription() {
+        return this.rawIn.meta.description ?? this.rawIn.defaultShortDescription;
+    }
+    innerToJsonSchema(ctx) {
+        return ctx.fallback.morph({
+            code: "morph",
+            base: this.rawIn.toJsonSchemaRecurse(ctx),
+            out: this.introspectableOut?.toJsonSchemaRecurse(ctx) ?? null
+        });
+    }
+    compile(js) {
+        if (js.traversalKind === "Allows") {
+            if (!this.introspectableIn)
+                return;
+            js.return(js.invoke(this.introspectableIn));
+            return;
+        }
+        if (this.introspectableIn)
+            js.line(js.invoke(this.introspectableIn));
+        js.line(`ctx.queueMorphs(${this.compiledMorphs})`);
+    }
+    traverseAllows = (data, ctx) => !this.introspectableIn || this.introspectableIn.traverseAllows(data, ctx);
+    traverseApply = (data, ctx) => {
+        if (this.introspectableIn)
+            this.introspectableIn.traverseApply(data, ctx);
+        ctx.queueMorphs(this.morphs);
+    };
+    /** Check if the morphs of r are equal to those of this node */
+    hasEqualMorphs(r) {
+        return arrayEquals(this.morphs, r.morphs, {
+            isEqual: (lMorph, rMorph) => lMorph === rMorph ||
+                (hasArkKind(lMorph, "root") &&
+                    hasArkKind(rMorph, "root") &&
+                    lMorph.equals(rMorph))
+        });
+    }
+}
+export const Morph = {
+    implementation,
+    Node: MorphNode
+};
+export const writeMorphIntersectionMessage = (lDescription, rDescription) => `The intersection of distinct morphs at a single path is indeterminate:
+Left: ${lDescription}
+Right: ${rDescription}`;

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

@@ -0,0 +1,53 @@
+import { type BuiltinObjectKind, type Constructor } from "@ark/util";
+import type { BaseErrorContext, BaseNormalizedSchema, declareNode } from "../shared/declare.ts";
+import { type nodeImplementationOf } from "../shared/implement.ts";
+import type { JsonSchema } from "../shared/jsonSchema.ts";
+import type { ToJsonSchema } from "../shared/toJsonSchema.ts";
+import type { TraverseAllows } from "../shared/traversal.ts";
+import { InternalBasis } from "./basis.ts";
+export declare namespace Proto {
+    type Reference = Constructor | BuiltinObjectKind;
+    type Schema<proto extends Reference = Reference> = proto | ExpandedSchema<proto>;
+    interface NormalizedSchema<proto extends Constructor = Constructor> extends BaseNormalizedSchema {
+        readonly proto: proto;
+        readonly dateAllowsInvalid?: boolean;
+    }
+    interface ExpandedSchema<proto extends Reference = Reference> {
+        readonly proto: proto;
+        readonly dateAllowsInvalid?: boolean;
+    }
+    interface Inner<proto extends Constructor = Constructor> {
+        readonly proto: proto;
+        readonly dateAllowsInvalid?: boolean;
+    }
+    interface ErrorContext extends BaseErrorContext<"proto">, Inner {
+    }
+    interface Declaration extends declareNode<{
+        kind: "proto";
+        schema: Schema;
+        normalizedSchema: NormalizedSchema;
+        inner: Inner;
+        errorContext: ErrorContext;
+    }> {
+    }
+    type Node = ProtoNode;
+}
+export declare class ProtoNode extends InternalBasis<Proto.Declaration> {
+    builtinName: BuiltinObjectKind | null;
+    serializedConstructor: string;
+    private readonly requiresInvalidDateCheck;
+    traverseAllows: TraverseAllows;
+    compiledCondition: string;
+    compiledNegation: string;
+    protected innerToJsonSchema(ctx: ToJsonSchema.Context): JsonSchema;
+    expression: string;
+    get nestableExpression(): string;
+    readonly domain = "object";
+    get defaultShortDescription(): string;
+}
+export declare const Proto: {
+    implementation: nodeImplementationOf<Proto.Declaration>;
+    Node: typeof ProtoNode;
+    writeBadInvalidDateMessage: (actual: Constructor) => string;
+    writeInvalidSchemaMessage: (actual: unknown) => string;
+};

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

@@ -0,0 +1,101 @@
+import { builtinConstructors, constructorExtends, domainOf, getBuiltinNameOfConstructor, hasKey, objectKindDescriptions, objectKindOrDomainOf, throwParseError } from "@ark/util";
+import { Disjoint } from "../shared/disjoint.js";
+import { defaultValueSerializer, implementNode } from "../shared/implement.js";
+import { $ark } from "../shared/registry.js";
+import { isNode } from "../shared/utils.js";
+import { InternalBasis } from "./basis.js";
+const implementation = implementNode({
+    kind: "proto",
+    hasAssociatedError: true,
+    collapsibleKey: "proto",
+    keys: {
+        proto: {
+            serialize: ctor => getBuiltinNameOfConstructor(ctor) ?? defaultValueSerializer(ctor)
+        },
+        dateAllowsInvalid: {}
+    },
+    normalize: schema => {
+        const normalized = typeof schema === "string" ? { proto: builtinConstructors[schema] }
+            : typeof schema === "function" ?
+                isNode(schema) ? schema
+                    : { proto: schema }
+                : typeof schema.proto === "string" ?
+                    { ...schema, proto: builtinConstructors[schema.proto] }
+                    : schema;
+        if (typeof normalized.proto !== "function")
+            throwParseError(Proto.writeInvalidSchemaMessage(normalized.proto));
+        if (hasKey(normalized, "dateAllowsInvalid") && normalized.proto !== Date)
+            throwParseError(Proto.writeBadInvalidDateMessage(normalized.proto));
+        return normalized;
+    },
+    applyConfig: (schema, config) => {
+        if (schema.dateAllowsInvalid === undefined &&
+            schema.proto === Date &&
+            config.dateAllowsInvalid)
+            return { ...schema, dateAllowsInvalid: true };
+        return schema;
+    },
+    defaults: {
+        description: node => node.builtinName ?
+            objectKindDescriptions[node.builtinName]
+            : `an instance of ${node.proto.name}`,
+        actual: data => data instanceof Date && data.toString() === "Invalid Date" ?
+            "an invalid Date"
+            : objectKindOrDomainOf(data)
+    },
+    intersections: {
+        proto: (l, r) => l.proto === Date && r.proto === Date ?
+            // since l === r is handled by default,
+            // exactly one of l or r must have allow invalid dates
+            l.dateAllowsInvalid ?
+                r
+                : l
+            : constructorExtends(l.proto, r.proto) ? l
+                : constructorExtends(r.proto, l.proto) ? r
+                    : Disjoint.init("proto", l, r),
+        domain: (proto, domain) => domain.domain === "object" ?
+            proto
+            : Disjoint.init("domain", $ark.intrinsic.object.internal, domain)
+    }
+});
+export class ProtoNode extends InternalBasis {
+    builtinName = getBuiltinNameOfConstructor(this.proto);
+    serializedConstructor = this.json.proto;
+    requiresInvalidDateCheck = this.proto === Date && !this.dateAllowsInvalid;
+    traverseAllows = this.requiresInvalidDateCheck ?
+        data => data instanceof Date && data.toString() !== "Invalid Date"
+        : data => data instanceof this.proto;
+    compiledCondition = `data instanceof ${this.serializedConstructor}${this.requiresInvalidDateCheck ? ` && data.toString() !== "Invalid Date"` : ""}`;
+    compiledNegation = `!(${this.compiledCondition})`;
+    innerToJsonSchema(ctx) {
+        switch (this.builtinName) {
+            case "Array":
+                return {
+                    type: "array"
+                };
+            case "Date":
+                return (ctx.fallback.date?.({ code: "date", base: {} }) ??
+                    ctx.fallback.proto({ code: "proto", base: {}, proto: this.proto }));
+            default:
+                return ctx.fallback.proto({
+                    code: "proto",
+                    base: {},
+                    proto: this.proto
+                });
+        }
+    }
+    expression = this.dateAllowsInvalid ? "Date | InvalidDate" : this.proto.name;
+    get nestableExpression() {
+        return this.dateAllowsInvalid ? `(${this.expression})` : this.expression;
+    }
+    domain = "object";
+    get defaultShortDescription() {
+        return this.description;
+    }
+}
+export const Proto = {
+    implementation,
+    Node: ProtoNode,
+    writeBadInvalidDateMessage: (actual) => `dateAllowsInvalid may only be specified with constructor Date (was ${actual.name})`,
+    writeInvalidSchemaMessage: (actual) => `instanceOf operand must be a function (was ${domainOf(actual)})`
+};