@blade-hq/agent-client 1.1.1 → 1.1.3

package/node_modules/arktype/out/parser/ast/infer.d.ts

@@ -0,0 +1,25 @@
+import type { arkKeyOf, array } from "@ark/util";
+import type { distill, inferIntersection, inferPipe, LimitLiteral, withDefault } from "../../attributes.ts";
+import type { type } from "../../keywords/keywords.ts";
+import type { inferDefinition } from "../definition.ts";
+import type { Comparator } from "../reduce/shared.ts";
+import type { InfixToken, PostfixToken } from "../shift/tokens.ts";
+import type { GenericInstantiationAst, inferGenericInstantiation } from "./generic.ts";
+export type inferAstRoot<ast, $, args> = ast extends array ? inferExpression<ast, $, args> : never;
+export type inferAstIn<ast, $, args> = distill.In<inferAstRoot<ast, $, args>>;
+export type inferAstOut<ast, $, args> = distill.Out<inferAstRoot<ast, $, args>>;
+export type DefAst<def = unknown, alias extends string = string> = [
+    def,
+    "def",
+    alias
+];
+export type InferredAst<t = unknown, def extends string = string> = [
+    t,
+    "inferred",
+    def
+];
+export type inferExpression<ast, $, args> = ast extends array ? ast extends InferredAst<infer resolution> ? resolution : ast extends DefAst<infer def> ? inferDefinition<def, $, args> : ast extends GenericInstantiationAst<infer g, infer argAsts> ? inferGenericInstantiation<g, argAsts, $, args> : ast[1] extends "[]" ? inferExpression<ast[0], $, args>[] : ast[1] extends "|" ? inferExpression<ast[0], $, args> | inferExpression<ast[2], $, args> : ast[1] extends "&" ? inferIntersection<inferExpression<ast[0], $, args>, inferExpression<ast[2], $, args>> : ast[1] extends "|>" ? inferPipe<inferExpression<ast[0], $, args>, inferExpression<ast[2], $, args>> : ast[1] extends "=" ? type.infer<ast[2]> extends infer defaultValue ? withDefault<inferExpression<ast[0], $, args>, defaultValue> : never : ast[1] extends "#" ? type.brand<inferExpression<ast[0], $, args>, ast[2]> : ast[1] extends Comparator ? ast[0] extends LimitLiteral ? inferExpression<ast[2], $, args> : inferExpression<ast[0], $, args> : ast[1] extends "%" ? inferExpression<ast[0], $, args> : ast[1] extends "?" ? inferExpression<ast[0], $, args> : ast[0] extends "keyof" ? arkKeyOf<inferExpression<ast[1], $, args>> : never : never;
+export type PrefixOperator = "keyof" | "instanceof" | "===" | "node";
+export type PrefixExpression<operator extends PrefixOperator = PrefixOperator, operand = unknown> = [operator, operand];
+export type PostfixExpression<operator extends PostfixToken = PostfixToken, operand = unknown> = readonly [operand, operator];
+export type InfixExpression<operator extends InfixToken = InfixToken, l = unknown, r = unknown> = [l, operator, r];

package/node_modules/arktype/out/parser/ast/infer.js

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

package/node_modules/arktype/out/parser/ast/keyof.d.ts

@@ -0,0 +1,7 @@
+import type { writeNonStructuralOperandMessage } from "@ark/schema";
+import type { ErrorMessage, typeToString } from "@ark/util";
+import type { inferAstRoot } from "./infer.ts";
+import type { validateAst } from "./validate.ts";
+export type validateKeyof<operandAst, $, args> = inferAstRoot<operandAst, $, args> extends infer data ? [
+    data
+] extends [object] ? validateAst<operandAst, $, args> : ErrorMessage<writeNonStructuralOperandMessage<"keyof", typeToString<data>>> : never;

package/node_modules/arktype/out/parser/ast/keyof.js

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

package/node_modules/arktype/out/parser/ast/utils.d.ts

@@ -0,0 +1,8 @@
+import type { satisfy, Stringifiable } from "@ark/util";
+import type { Comparator } from "../reduce/shared.ts";
+import type { OperatorToken } from "../shift/tokens.ts";
+import type { DefAst, InferredAst, InfixExpression, PostfixExpression } from "./infer.ts";
+export type astToString<ast> = ast extends InferredAst | DefAst ? ast[2] : ast extends PostfixExpression<infer operator, infer operand> ? operator extends "[]" ? `${astToString<operand>}[]` : never : ast extends InfixExpression<infer operator, infer l, infer r> ? operator extends "&" | "|" | "%" | Comparator ? `${astToString<l>} ${operator} ${astToString<r>}` : never : ast extends Stringifiable ? `${ast extends bigint ? `${ast}n` : ast}` : "...";
+export type ConstraintOperator = satisfy<OperatorToken, "%" | Comparator>;
+export type writeConstrainedMorphMessage<constrainedAst> = `To constrain the output of ${astToString<constrainedAst>}, pipe like myMorph.to('number > 0').
+To constrain the input, intersect like myMorph.and('number > 0').`;

package/node_modules/arktype/out/parser/ast/utils.js

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

package/node_modules/arktype/out/parser/ast/validate.d.ts

@@ -0,0 +1,30 @@
+import type { arkKind, PrivateDeclaration, writeMissingSubmoduleAccessMessage } from "@ark/schema";
+import type { anyOrNever, BigintLiteral, Completion, ErrorMessage, NumberLiteral, writeMalformedNumericLiteralMessage } from "@ark/util";
+import type { Generic } from "../../generic.ts";
+import type { BranchOperator, Comparator } from "../reduce/shared.ts";
+import type { writeInvalidGenericArgCountMessage } from "../shift/operand/genericArgs.ts";
+import type { UnitLiteral } from "../shift/operator/default.ts";
+import type { parseString } from "../string.ts";
+import type { validateRange } from "./bounds.ts";
+import type { validateDefault } from "./default.ts";
+import type { validateDivisor } from "./divisor.ts";
+import type { GenericInstantiationAst, validateGenericInstantiation } from "./generic.ts";
+import type { DefAst, InferredAst, InfixExpression, PostfixExpression } from "./infer.ts";
+import type { validateKeyof } from "./keyof.ts";
+import type { astToString } from "./utils.ts";
+export type validateAst<ast, $, args> = ast extends ErrorMessage ? ast : ast extends InferredAst ? validateInferredAst<ast[0], ast[2]> : ast extends DefAst ? ast[2] extends PrivateDeclaration<infer name> ? ErrorMessage<writePrefixedPrivateReferenceMessage<name>> : undefined : ast extends PostfixExpression<"[]" | "?", infer operand> ? validateAst<operand, $, args> : ast extends InfixExpression<infer operator, infer l, infer r> ? operator extends BranchOperator ? validateInfix<ast, $, args> : operator extends Comparator ? validateRange<l, operator, r, $, args> : operator extends "%" ? validateDivisor<l, $, args> : operator extends "=" ? validateDefault<l, r & UnitLiteral, $, args> : operator extends "#" ? validateAst<l, $, args> : ErrorMessage<writeUnexpectedExpressionMessage<astToString<ast>>> : ast extends ["keyof", infer operand] ? validateKeyof<operand, $, args> : ast extends GenericInstantiationAst<infer g, infer argAsts> ? validateGenericInstantiation<g, argAsts, $, args> : ErrorMessage<writeUnexpectedExpressionMessage<astToString<ast>>> & {
+    ast: ast;
+};
+type writeUnexpectedExpressionMessage<expression extends string> = `Failed to parse the expression resulting from ${expression}`;
+export declare const writePrefixedPrivateReferenceMessage: <name extends string>(name: name) => writePrefixedPrivateReferenceMessage<name>;
+export type writePrefixedPrivateReferenceMessage<name extends string> = `Private type references should not include '#'. Use '${name}' instead.`;
+type validateInferredAst<inferred, def extends string> = def extends NumberLiteral ? number extends inferred ? ErrorMessage<writeMalformedNumericLiteralMessage<def, "number">> : undefined : def extends BigintLiteral ? bigint extends inferred ? ErrorMessage<writeMalformedNumericLiteralMessage<def, "bigint">> : undefined : [inferred] extends [anyOrNever] ? undefined : def extends PrivateDeclaration<infer name> ? ErrorMessage<writePrefixedPrivateReferenceMessage<name>> : inferred extends Generic ? ErrorMessage<writeInvalidGenericArgCountMessage<def, inferred["names"], []>> : inferred extends {
+    [arkKind]: "module";
+} ? "root" extends keyof inferred ? undefined : ErrorMessage<writeMissingSubmoduleAccessMessage<def>> : def extends ErrorMessage ? def : undefined;
+export type validateString<def extends string, $, args> = parseString<def, $, args> extends infer ast ? validateAst<ast, $, args> extends infer result extends ErrorMessage ? result extends Completion<infer text> ? text : result : def : never;
+type validateInfix<ast extends InfixExpression, $, args> = validateAst<ast[0], $, args> extends infer e extends ErrorMessage ? e : validateAst<ast[2], $, args> extends infer e extends ErrorMessage ? e : undefined;
+export declare const shallowOptionalMessage = "Optional definitions like 'string?' are only valid as properties in an object or tuple";
+export type shallowOptionalMessage = typeof shallowOptionalMessage;
+export declare const shallowDefaultableMessage = "Defaultable definitions like 'number = 0' are only valid as properties in an object or tuple";
+export type shallowDefaultableMessage = typeof shallowDefaultableMessage;
+export {};

package/node_modules/arktype/out/parser/ast/validate.js

@@ -0,0 +1,3 @@
+export const writePrefixedPrivateReferenceMessage = (name) => `Private type references should not include '#'. Use '${name}' instead.`;
+export const shallowOptionalMessage = "Optional definitions like 'string?' are only valid as properties in an object or tuple";
+export const shallowDefaultableMessage = "Defaultable definitions like 'number = 0' are only valid as properties in an object or tuple";

package/node_modules/arktype/out/parser/definition.d.ts

@@ -0,0 +1,30 @@
+import { type BaseParseContext, type BaseRoot, type StandardSchemaV1 } from "@ark/schema";
+import { type anyOrNever, type array, type ErrorMessage, type Fn, type ifEmptyObjectLiteral, type objectKindOrDomainOf, type Primitive } from "@ark/util";
+import type { Out } from "../attributes.ts";
+import type { type } from "../keywords/keywords.ts";
+import type { InnerParseResult } from "../scope.ts";
+import type { shallowDefaultableMessage, shallowOptionalMessage, validateString } from "./ast/validate.ts";
+import { type inferObjectLiteral, type validateObjectLiteral } from "./objectLiteral.ts";
+import type { isDefaultable, OptionalPropertyDefinition } from "./property.ts";
+import { type BaseCompletions, type inferString } from "./string.ts";
+import { type inferTupleExpression, type maybeValidateTupleExpression, type TupleExpression } from "./tupleExpressions.ts";
+import { type inferTupleLiteral, type validateTupleLiteral } from "./tupleLiteral.ts";
+export declare const parseInnerDefinition: (def: unknown, ctx: BaseParseContext) => InnerParseResult;
+export declare const parseObject: (def: object, ctx: BaseParseContext) => BaseRoot;
+export type inferDefinition<def, $, args> = [
+    def
+] extends [anyOrNever] ? def : def extends type.cast<infer t> ? ifEmptyObjectLiteral<def, object, t> : def extends ThunkCast<infer t> ? t : def extends string ? inferString<def, $, args> : def extends array ? inferTuple<def, $, args> : def extends RegExp ? string : def extends StandardSchemaV1 ? inferStandardSchema<def> : def extends object ? inferObjectLiteral<def, $, args> : never;
+type inferStandardSchema<schema extends StandardSchemaV1, i = StandardSchemaV1.InferInput<schema>, o = StandardSchemaV1.InferOutput<schema>> = [i, o] extends [o, i] ? i : (In: i) => Out<o>;
+export type validateDefinition<def, $, args> = null extends undefined ? ErrorMessage<`'strict' or 'strictNullChecks' must be set to true in your tsconfig's 'compilerOptions'`> : [def] extends [anyOrNever] ? def : def extends OptionalPropertyDefinition ? ErrorMessage<shallowOptionalMessage> : isDefaultable<def, $, args> extends true ? ErrorMessage<shallowDefaultableMessage> : validateInnerDefinition<def, $, args>;
+export type validateInnerDefinition<def, $, args> = [
+    def
+] extends [TerminalObjectDefinition] ? def : def extends string ? validateString<def, $, args> : unknown extends def ? BaseCompletions<$, args> | {} : def extends readonly unknown[] ? validateTuple<def, $, args> : def extends BadDefinitionType ? ErrorMessage<writeBadDefinitionTypeMessage<objectKindOrDomainOf<def>>> : validateObjectLiteral<def, $, args>;
+export declare const parseTuple: (def: array, ctx: BaseParseContext) => BaseRoot;
+export type validateTuple<def extends array, $, args> = maybeValidateTupleExpression<def, $, args> extends infer result ? result extends null ? validateTupleLiteral<def, $, args> : result : never;
+export type inferTuple<def extends array, $, args> = def extends TupleExpression ? inferTupleExpression<def, $, args> : inferTupleLiteral<def, $, args>;
+export type TerminalObjectDefinition = type.cast<unknown> | Fn | RegExp | StandardSchemaV1;
+export type ThunkCast<t = unknown> = () => type.cast<t>;
+type BadDefinitionType = Exclude<Primitive, string>;
+export declare const writeBadDefinitionTypeMessage: <actual extends string>(actual: actual) => writeBadDefinitionTypeMessage<actual>;
+type writeBadDefinitionTypeMessage<actual extends string> = `Type definitions must be strings or objects (was ${actual})`;
+export {};

package/node_modules/arktype/out/parser/definition.js

@@ -0,0 +1,74 @@
+import { hasArkKind } from "@ark/schema";
+import { domainOf, hasDomain, isThunk, objectKindOf, printable, throwParseError, uncapitalize } from "@ark/util";
+import { parseObjectLiteral } from "./objectLiteral.js";
+import { parseString } from "./string.js";
+import { maybeParseTupleExpression } from "./tupleExpressions.js";
+import { parseTupleLiteral } from "./tupleLiteral.js";
+const parseCache = {};
+export const parseInnerDefinition = (def, ctx) => {
+    if (typeof def === "string") {
+        if (ctx.args && Object.keys(ctx.args).some(k => def.includes(k))) {
+            // we can only rely on the cache if there are no contextual
+            // resolutions like "this" or generic args
+            return parseString(def, ctx);
+        }
+        const scopeCache = (parseCache[ctx.$.name] ??= {});
+        return (scopeCache[def] ??= parseString(def, ctx));
+    }
+    return hasDomain(def, "object") ?
+        parseObject(def, ctx)
+        : throwParseError(writeBadDefinitionTypeMessage(domainOf(def)));
+};
+export const parseObject = (def, ctx) => {
+    const objectKind = objectKindOf(def);
+    switch (objectKind) {
+        case undefined:
+            if (hasArkKind(def, "root"))
+                return def;
+            if ("~standard" in def)
+                return parseStandardSchema(def, ctx);
+            return parseObjectLiteral(def, ctx);
+        case "Array":
+            return parseTuple(def, ctx);
+        case "RegExp":
+            return ctx.$.node("intersection", {
+                domain: "string",
+                pattern: def
+            }, { prereduced: true });
+        case "Function": {
+            const resolvedDef = isThunk(def) ? def() : def;
+            if (hasArkKind(resolvedDef, "root"))
+                return resolvedDef;
+            return throwParseError(writeBadDefinitionTypeMessage("Function"));
+        }
+        default:
+            return throwParseError(writeBadDefinitionTypeMessage(objectKind ?? printable(def)));
+    }
+};
+const parseStandardSchema = (def, ctx) => ctx.$.intrinsic.unknown.pipe((v, ctx) => {
+    const result = def["~standard"].validate(v);
+    if (!result.issues)
+        return result.value;
+    for (const { message, path } of result.issues) {
+        if (path) {
+            if (path.length) {
+                ctx.error({
+                    problem: uncapitalize(message),
+                    relativePath: path.map(k => (typeof k === "object" ? k.key : k))
+                });
+            }
+            else {
+                ctx.error({
+                    message
+                });
+            }
+        }
+        else {
+            ctx.error({
+                message
+            });
+        }
+    }
+});
+export const parseTuple = (def, ctx) => maybeParseTupleExpression(def, ctx) ?? parseTupleLiteral(def, ctx);
+export const writeBadDefinitionTypeMessage = (actual) => `Type definitions must be strings or objects (was ${actual})`;

package/node_modules/arktype/out/parser/objectLiteral.d.ts

@@ -0,0 +1,70 @@
+import { type BaseParseContext, type BaseRoot, type writeInvalidPropertyKeyMessage } from "@ark/schema";
+import { Backslash, type anyOrNever, type Dict, type ErrorMessage, type ErrorType, type Key, type merge, type show } from "@ark/util";
+import type { validateString } from "./ast/validate.ts";
+import type { inferDefinition } from "./definition.ts";
+import { type OptionalPropertyDefinition, type validateProperty } from "./property.ts";
+export declare const parseObjectLiteral: (def: Dict, ctx: BaseParseContext) => BaseRoot;
+export type inferObjectLiteral<def extends object, $, args> = show<"..." extends keyof def ? merge<inferDefinition<def["..."], $, args>, _inferObjectLiteral<def, $, args>> : _inferObjectLiteral<def, $, args>>;
+/**
+ * Infers the contents of an object literal, ignoring a spread definition
+ */
+type _inferObjectLiteral<def extends object, $, args> = {
+    -readonly [k in keyof def as nonOptionalKeyFromEntry<k, def[k], $, args>]: inferDefinition<def[k], $, args>;
+} & {
+    -readonly [k in keyof def as optionalKeyFromEntry<k, def[k]>]?: def[k] extends OptionalPropertyDefinition<infer baseDef> ? inferDefinition<baseDef, $, args> : inferDefinition<def[k], $, args>;
+};
+export type validateObjectLiteral<def, $, args> = {
+    [k in keyof def]: preparseKey<k> extends (infer parsedKey extends PreparsedKey) ? parsedKey extends PreparsedEntryKey<"index"> ? validateString<parsedKey["normalized"], $, args> extends (ErrorMessage<infer message>) ? ErrorType<message> : inferDefinition<parsedKey["normalized"], $, args> extends Key ? validateProperty<def[k], parsedKey["kind"], $, args> : ErrorMessage<writeInvalidPropertyKeyMessage<parsedKey["normalized"]>> : validateProperty<def[k], parsedKey["kind"], $, args> : never;
+};
+type nonOptionalKeyFromEntry<k extends PropertyKey, v, $, args> = preparseKey<k> extends infer parsedKey ? parsedKey extends PreparsedEntryKey<"required"> ? [
+    v
+] extends [OptionalPropertyDefinition] ? [
+    v
+] extends [anyOrNever] ? parsedKey["normalized"] : never : parsedKey["normalized"] : parsedKey extends PreparsedEntryKey<"index"> ? inferDefinition<parsedKey["normalized"], $, args> & Key : never : never;
+type optionalKeyFromEntry<k extends PropertyKey, v> = preparseKey<k> extends infer parsedKey ? parsedKey extends PreparsedEntryKey<"optional"> ? parsedKey["normalized"] : v extends OptionalPropertyDefinition ? k : never : never;
+export declare const writeInvalidUndeclaredBehaviorMessage: (actual: unknown) => string;
+export declare const nonLeadingSpreadError = "Spread operator may only be used as the first key in an object";
+export type PreparsedKey = PreparsedEntryKey | PreparsedSpecialKey;
+type normalizedKeyKind<kind extends EntryKeyKind> = kind extends "index" ? string : Key;
+export type PreparsedEntryKey<kind extends EntryKeyKind = EntryKeyKind, normalized extends normalizedKeyKind<kind> = normalizedKeyKind<kind>> = {
+    kind: kind;
+    normalized: normalized;
+};
+export type PreparsedSpecialKey<kind extends SpecialKeyKind = SpecialKeyKind> = {
+    kind: kind;
+};
+declare namespace PreparsedKey {
+    type from<t extends PreparsedKey> = t;
+}
+export type ParsedKeyKind = EntryKeyKind | SpecialKeyKind;
+export type EntryKeyKind = "required" | "optional" | "index";
+export type SpecialKeyKind = "spread" | "undeclared";
+export type MetaKey = "..." | "+";
+export type IndexKey<def extends string = string> = `[${def}]`;
+export declare const preparseKey: (key: Key) => PreparsedKey;
+export type preparseKey<k> = k extends symbol ? PreparsedKey.from<{
+    kind: "required";
+    normalized: k;
+}> : k extends `${infer inner}?` ? inner extends `${infer baseName}${Backslash}` ? PreparsedKey.from<{
+    kind: "required";
+    normalized: `${baseName}?`;
+}> : PreparsedKey.from<{
+    kind: "optional";
+    normalized: inner;
+}> : k extends "+" ? {
+    kind: "undeclared";
+} : k extends "..." ? {
+    kind: "spread";
+} : k extends `${Backslash}${infer escapedMeta extends MetaKey}` ? PreparsedKey.from<{
+    kind: "required";
+    normalized: escapedMeta;
+}> : k extends IndexKey<infer def> ? PreparsedKey.from<{
+    kind: "index";
+    normalized: def;
+}> : PreparsedKey.from<{
+    kind: "required";
+    normalized: k extends (`${Backslash}${infer escapedIndexKey extends IndexKey}`) ? escapedIndexKey : k extends Key ? k : `${k & number}`;
+}>;
+export declare const writeInvalidSpreadTypeMessage: <def extends string>(def: def) => writeInvalidSpreadTypeMessage<def>;
+export type writeInvalidSpreadTypeMessage<def extends string> = `Spread operand must resolve to an object literal type (was ${def})`;
+export {};

package/node_modules/arktype/out/parser/objectLiteral.js

@@ -0,0 +1,113 @@
+import { intrinsic, normalizeIndex } from "@ark/schema";
+import { append, Backslash, isArray, isEmptyObject, printable, stringAndSymbolicEntriesOf, throwParseError } from "@ark/util";
+import { invalidDefaultableKeyKindMessage, invalidOptionalKeyKindMessage, parseProperty } from "./property.js";
+export const parseObjectLiteral = (def, ctx) => {
+    let spread;
+    const structure = {};
+    // We only allow a spread operator to be used as the first key in an object
+    // because to match JS behavior any keys before the spread are overwritten
+    // by the values in the target object, so there'd be no useful purpose in having it
+    // anywhere except for the beginning.
+    const defEntries = stringAndSymbolicEntriesOf(def);
+    for (const [k, v] of defEntries) {
+        const parsedKey = preparseKey(k);
+        if (parsedKey.kind === "spread") {
+            if (!isEmptyObject(structure))
+                return throwParseError(nonLeadingSpreadError);
+            const operand = ctx.$.parseOwnDefinitionFormat(v, ctx);
+            // treat object domain as empty for spreading (useful for generic constraints)
+            if (operand.equals(intrinsic.object))
+                continue;
+            if (!operand.hasKind("intersection") ||
+                // still error on attempts to spread proto nodes like ...Date
+                !operand.basis?.equals(intrinsic.object)) {
+                return throwParseError(writeInvalidSpreadTypeMessage(operand.expression));
+            }
+            spread = operand.structure;
+            continue;
+        }
+        if (parsedKey.kind === "undeclared") {
+            if (v !== "reject" && v !== "delete" && v !== "ignore")
+                throwParseError(writeInvalidUndeclaredBehaviorMessage(v));
+            structure.undeclared = v;
+            continue;
+        }
+        const parsedValue = parseProperty(v, ctx);
+        const parsedEntryKey = parsedKey;
+        if (parsedKey.kind === "required") {
+            if (!isArray(parsedValue)) {
+                appendNamedProp(structure, "required", {
+                    key: parsedKey.normalized,
+                    value: parsedValue
+                }, ctx);
+            }
+            else {
+                appendNamedProp(structure, "optional", parsedValue[1] === "=" ?
+                    {
+                        key: parsedKey.normalized,
+                        value: parsedValue[0],
+                        default: parsedValue[2]
+                    }
+                    : {
+                        key: parsedKey.normalized,
+                        value: parsedValue[0]
+                    }, ctx);
+            }
+            continue;
+        }
+        if (isArray(parsedValue)) {
+            if (parsedValue[1] === "?")
+                throwParseError(invalidOptionalKeyKindMessage);
+            if (parsedValue[1] === "=")
+                throwParseError(invalidDefaultableKeyKindMessage);
+        }
+        // value must be a BaseRoot at this point
+        if (parsedKey.kind === "optional") {
+            appendNamedProp(structure, "optional", {
+                key: parsedKey.normalized,
+                value: parsedValue
+            }, ctx);
+            continue;
+        }
+        // must be index at this point
+        const signature = ctx.$.parseOwnDefinitionFormat(parsedEntryKey.normalized, ctx);
+        const normalized = normalizeIndex(signature, parsedValue, ctx.$);
+        if (normalized.index)
+            structure.index = append(structure.index, normalized.index);
+        if (normalized.required)
+            structure.required = append(structure.required, normalized.required);
+    }
+    const structureNode = ctx.$.node("structure", structure);
+    return ctx.$.parseSchema({
+        domain: "object",
+        structure: spread?.merge(structureNode) ?? structureNode
+    });
+};
+const appendNamedProp = (structure, kind, inner, ctx) => {
+    structure[kind] = append(
+    // doesn't seem like this cast should be necessary
+    structure[kind], ctx.$.node(kind, inner));
+};
+export const writeInvalidUndeclaredBehaviorMessage = (actual) => `Value of '+' key must be 'reject', 'delete', or 'ignore' (was ${printable(actual)})`;
+export const nonLeadingSpreadError = "Spread operator may only be used as the first key in an object";
+export const preparseKey = (key) => typeof key === "symbol" ? { kind: "required", normalized: key }
+    : key[key.length - 1] === "?" ?
+        key[key.length - 2] === Backslash ?
+            { kind: "required", normalized: `${key.slice(0, -2)}?` }
+            : {
+                kind: "optional",
+                normalized: key.slice(0, -1)
+            }
+        : key[0] === "[" && key[key.length - 1] === "]" ?
+            { kind: "index", normalized: key.slice(1, -1) }
+            : key[0] === Backslash && key[1] === "[" && key[key.length - 1] === "]" ?
+                { kind: "required", normalized: key.slice(1) }
+                : key === "..." ? { kind: "spread" }
+                    : key === "+" ? { kind: "undeclared" }
+                        : {
+                            kind: "required",
+                            normalized: key === "\\..." ? "..."
+                                : key === "\\+" ? "+"
+                                    : key
+                        };
+export const writeInvalidSpreadTypeMessage = (def) => `Spread operand must resolve to an object literal type (was ${def})`;

package/node_modules/arktype/out/parser/property.d.ts

@@ -0,0 +1,34 @@
+import type { BaseParseContext, BaseRoot, UndeclaredKeyBehavior } from "@ark/schema";
+import { type anyOrNever, type ErrorMessage, type ErrorType, type typeToString } from "@ark/util";
+import { type inferDefinition, type validateInnerDefinition } from "./definition.ts";
+import type { ParsedKeyKind, writeInvalidSpreadTypeMessage } from "./objectLiteral.ts";
+import type { ParsedDefaultableProperty } from "./shift/operator/default.ts";
+import type { parseString } from "./string.ts";
+export type ParsedPropertyKind = "plain" | "optional" | "defaultable";
+export type ParsedProperty = ParsedRequiredProperty | ParsedOptionalProperty | ParsedDefaultableProperty;
+export type ParsedRequiredProperty = BaseRoot;
+export type ParsedOptionalProperty = readonly [BaseRoot, "?"];
+export declare const parseProperty: (def: unknown, ctx: BaseParseContext) => ParsedProperty;
+export type validateProperty<def, keyKind extends ParsedKeyKind, $, args> = [
+    def
+] extends [anyOrNever] ? 
+/** this extra [anyOrNever] check is required to ensure that nested `type` invocations
+ * like the following are not prematurely validated by the outer call:
+ *
+ * ```ts
+ * type({
+ * 	"test?": type("string").pipe(x => x === "true")
+ * })
+ * ```
+ */
+def : keyKind extends "spread" ? def extends validateInnerDefinition<def, $, args> ? inferDefinition<def, $, args> extends object ? def : ErrorType<writeInvalidSpreadTypeMessage<typeToString<inferDefinition<def, $, args>>>> : validateInnerDefinition<def, $, args> : keyKind extends "undeclared" ? UndeclaredKeyBehavior : keyKind extends "required" ? validateInnerDefinition<def, $, args> : def extends OptionalPropertyDefinition ? ErrorMessage<invalidOptionalKeyKindMessage> : isDefaultable<def, $, args> extends true ? ErrorMessage<invalidDefaultableKeyKindMessage> : validateInnerDefinition<def, $, args>;
+export type isDefaultable<def, $, args> = def extends DefaultablePropertyTuple ? true : def extends PossibleDefaultableStringDefinition ? parseString<def, $, args> extends DefaultablePropertyTuple ? true : false : false;
+export type OptionalPropertyDefinition<baseDef = unknown> = OptionalPropertyTuple<baseDef> | OptionalPropertyString<baseDef & string>;
+export type OptionalPropertyString<baseDef extends string = string> = `${baseDef}?`;
+export type OptionalPropertyTuple<baseDef = unknown> = readonly [baseDef, "?"];
+export type PossibleDefaultableStringDefinition = `${string}=${string}`;
+export type DefaultablePropertyTuple<baseDef = unknown, thunkableProperty = unknown> = readonly [baseDef, "=", thunkableProperty];
+export declare const invalidOptionalKeyKindMessage = "Only required keys may make their values optional, e.g. { [mySymbol]: ['number', '?'] }";
+export type invalidOptionalKeyKindMessage = typeof invalidOptionalKeyKindMessage;
+export declare const invalidDefaultableKeyKindMessage = "Only required keys may specify default values, e.g. { value: 'number = 0' }";
+export type invalidDefaultableKeyKindMessage = typeof invalidDefaultableKeyKindMessage;

package/node_modules/arktype/out/parser/property.js

@@ -0,0 +1,16 @@
+import { isArray } from "@ark/util";
+import { parseInnerDefinition } from "./definition.js";
+export const parseProperty = (def, ctx) => {
+    if (isArray(def)) {
+        if (def[1] === "=")
+            return [ctx.$.parseOwnDefinitionFormat(def[0], ctx), "=", def[2]];
+        if (def[1] === "?")
+            return [ctx.$.parseOwnDefinitionFormat(def[0], ctx), "?"];
+    }
+    // string-embedded defaults/optionals are handled by the string parser
+    return parseInnerDefinition(def, ctx);
+};
+// single quote use here is better for TypeScript's inlined error to avoid escapes
+export const invalidOptionalKeyKindMessage = `Only required keys may make their values optional, e.g. { [mySymbol]: ['number', '?'] }`;
+// single quote use here is better for TypeScript's inlined error to avoid escapes
+export const invalidDefaultableKeyKindMessage = `Only required keys may specify default values, e.g. { value: 'number = 0' }`;

package/node_modules/arktype/out/parser/reduce/dynamic.d.ts

@@ -0,0 +1,42 @@
+import type { BaseParseContext, BaseRoot } from "@ark/schema";
+import { type requireKeys, type Scanner } from "@ark/util";
+import type { LimitLiteral } from "../../attributes.ts";
+import type { FinalizingLookahead, InfixToken } from "../shift/tokens.ts";
+import { type BranchOperator, type Comparator, type MinComparator, type OpenLeftBound, type StringifiablePrefixOperator } from "./shared.ts";
+type BranchState = {
+    prefixes: StringifiablePrefixOperator[];
+    leftBound: OpenLeftBound | null;
+    intersection: BaseRoot | null;
+    union: BaseRoot | null;
+    pipe: BaseRoot | null;
+};
+export type RootedRuntimeState = requireKeys<RuntimeState, "root">;
+export declare class RuntimeState {
+    root: BaseRoot | undefined;
+    branches: BranchState;
+    finalizer: FinalizingLookahead | undefined;
+    groups: BranchState[];
+    scanner: Scanner;
+    ctx: BaseParseContext;
+    constructor(scanner: Scanner, ctx: BaseParseContext);
+    error(message: string): never;
+    hasRoot(): this is RootedRuntimeState;
+    setRoot(root: BaseRoot): void;
+    unsetRoot(): this["root"];
+    constrainRoot(...args: Parameters<BaseRoot<any>["constrain"]>): void;
+    finalize(finalizer: FinalizingLookahead): void;
+    reduceLeftBound(limit: LimitLiteral, comparator: Comparator): void;
+    finalizeBranches(): void;
+    finalizeGroup(): void;
+    addPrefix(prefix: StringifiablePrefixOperator): void;
+    applyPrefixes(): void;
+    pushRootToBranch(token: BranchOperator): void;
+    parseUntilFinalizer(): RootedRuntimeState;
+    parseOperator(this: RootedRuntimeState): void;
+    parseOperand(): void;
+    private assertRangeUnset;
+    reduceGroupOpen(): void;
+    previousOperator(): MinComparator | StringifiablePrefixOperator | InfixToken | undefined;
+    shiftedBy(count: number): this;
+}
+export {};

package/node_modules/arktype/out/parser/reduce/dynamic.js

@@ -0,0 +1,153 @@
+import { isKeyOf, throwInternalError, throwParseError, writeUnclosedGroupMessage, writeUnmatchedGroupCloseMessage } from "@ark/util";
+import { parseOperand } from "../shift/operand/operand.js";
+import { parseOperator } from "../shift/operator/operator.js";
+import { parseUntilFinalizer } from "../string.js";
+import { invertedComparators, minComparators, writeMultipleLeftBoundsMessage, writeOpenRangeMessage, writeUnpairableComparatorMessage } from "./shared.js";
+export class RuntimeState {
+    root;
+    branches = {
+        prefixes: [],
+        leftBound: null,
+        intersection: null,
+        union: null,
+        pipe: null
+    };
+    finalizer;
+    groups = [];
+    scanner;
+    ctx;
+    constructor(scanner, ctx) {
+        this.scanner = scanner;
+        this.ctx = ctx;
+    }
+    error(message) {
+        return throwParseError(message);
+    }
+    hasRoot() {
+        return this.root !== undefined;
+    }
+    setRoot(root) {
+        this.root = root;
+    }
+    unsetRoot() {
+        const value = this.root;
+        this.root = undefined;
+        return value;
+    }
+    constrainRoot(...args) {
+        this.root = this.root.constrain(args[0], args[1]);
+    }
+    finalize(finalizer) {
+        if (this.groups.length)
+            return this.error(writeUnclosedGroupMessage(")"));
+        this.finalizeBranches();
+        this.finalizer = finalizer;
+    }
+    reduceLeftBound(limit, comparator) {
+        const invertedComparator = invertedComparators[comparator];
+        if (!isKeyOf(invertedComparator, minComparators))
+            return this.error(writeUnpairableComparatorMessage(comparator));
+        if (this.branches.leftBound) {
+            return this.error(writeMultipleLeftBoundsMessage(this.branches.leftBound.limit, this.branches.leftBound.comparator, limit, invertedComparator));
+        }
+        this.branches.leftBound = {
+            comparator: invertedComparator,
+            limit
+        };
+    }
+    finalizeBranches() {
+        this.assertRangeUnset();
+        if (this.branches.pipe) {
+            this.pushRootToBranch("|>");
+            this.root = this.branches.pipe;
+            return;
+        }
+        if (this.branches.union) {
+            this.pushRootToBranch("|");
+            this.root = this.branches.union;
+            return;
+        }
+        if (this.branches.intersection) {
+            this.pushRootToBranch("&");
+            this.root = this.branches.intersection;
+            return;
+        }
+        this.applyPrefixes();
+    }
+    finalizeGroup() {
+        this.finalizeBranches();
+        const topBranchState = this.groups.pop();
+        if (!topBranchState) {
+            return this.error(writeUnmatchedGroupCloseMessage(")", this.scanner.unscanned));
+        }
+        this.branches = topBranchState;
+    }
+    addPrefix(prefix) {
+        this.branches.prefixes.push(prefix);
+    }
+    applyPrefixes() {
+        while (this.branches.prefixes.length) {
+            const lastPrefix = this.branches.prefixes.pop();
+            this.root =
+                lastPrefix === "keyof" ?
+                    this.root.keyof()
+                    : throwInternalError(`Unexpected prefix '${lastPrefix}'`);
+        }
+    }
+    pushRootToBranch(token) {
+        this.assertRangeUnset();
+        this.applyPrefixes();
+        const root = this.root;
+        this.root = undefined;
+        this.branches.intersection =
+            this.branches.intersection?.rawAnd(root) ?? root;
+        if (token === "&")
+            return;
+        this.branches.union =
+            this.branches.union?.rawOr(this.branches.intersection) ??
+                this.branches.intersection;
+        this.branches.intersection = null;
+        if (token === "|")
+            return;
+        this.branches.pipe =
+            this.branches.pipe?.rawPipeOnce(this.branches.union) ??
+                this.branches.union;
+        this.branches.union = null;
+    }
+    parseUntilFinalizer() {
+        return parseUntilFinalizer(new RuntimeState(this.scanner, this.ctx));
+    }
+    parseOperator() {
+        return parseOperator(this);
+    }
+    parseOperand() {
+        return parseOperand(this);
+    }
+    assertRangeUnset() {
+        if (this.branches.leftBound) {
+            return this.error(writeOpenRangeMessage(this.branches.leftBound.limit, this.branches.leftBound.comparator));
+        }
+    }
+    reduceGroupOpen() {
+        this.groups.push(this.branches);
+        this.branches = {
+            prefixes: [],
+            leftBound: null,
+            union: null,
+            intersection: null,
+            pipe: null
+        };
+    }
+    previousOperator() {
+        return (this.branches.leftBound?.comparator ??
+            this.branches.prefixes[this.branches.prefixes.length - 1] ??
+            (this.branches.intersection ? "&"
+                : this.branches.union ? "|"
+                    : this.branches.pipe ? "|>"
+                        : undefined));
+    }
+    shiftedBy(count) {
+        this.scanner.jumpForward(count);
+        return this;
+    }
+}