@yaag/cli 0.1.0

package/assets/types/runtime/tool-probe-extension.d.ts

@@ -0,0 +1,12 @@
+interface ToolProbeAPI {
+    getActiveTools(): string[];
+    on(event: "session_start", handler: (event: unknown, context: ToolProbeContext) => void): void;
+}
+interface ToolProbeContext {
+    readonly ui: {
+        setStatus(key: string, text: string | undefined): void;
+    };
+}
+/** Reports pi's post-composition active tool names through the RPC UI channel. */
+export default function (pi: ToolProbeAPI): void;
+export {};

package/assets/types/runtime/tool-probe.d.ts

@@ -0,0 +1,30 @@
+import type { Frame } from "./transport.ts";
+/** The private status key used only by yaag's internal pi tool probe extension. */
+export declare const TOOL_PROBE_STATUS_KEY = "yaag.tool-probe.v1";
+/** Filesystem sibling path of the probe extension; decodes percent-escapes (e.g. spaces). */
+export declare function toolProbeExtensionPath(moduleUrl: string): string;
+/** Loadable source path for the private extension that reports pi's active tools. */
+export declare const TOOL_PROBE_EXTENSION_PATH: string;
+/** Startup collector for the private extension's effective-tool report. */
+export interface ToolProbe {
+    /** True when the frame belongs to the probe and must not cross the transport seam. */
+    accept(frame: Frame): boolean;
+    /** Resolves with active tool names or rejects on malformed output or timeout. */
+    wait(): Promise<readonly string[]>;
+    /** Rejects startup when the spawned pi process ends before reporting. */
+    fail(error: Error): void;
+}
+/**
+ * Returns promised tools that survive pi's final denylist composition.
+ *
+ * Null means no tool allowlist promised anything and therefore needs no probe.
+ */
+export declare function requestedToolNames(tools: readonly string[] | undefined, disallowedTools?: readonly string[] | undefined): readonly string[] | null;
+/** Creates a startup collector only when a non-empty allowlist promised tool selection. */
+export declare function createToolProbe(tools: readonly string[] | undefined, _disallowedTools?: readonly string[] | undefined, timeoutMs?: number): ToolProbe | null;
+/** True exactly for a status frame emitted by the private probe extension. */
+export declare function isToolProbeFrame(frame: Frame): boolean;
+/** Parses the private status payload, rejecting every malformed boundary. */
+export declare function parseToolProbeFrame(frame: Frame): readonly string[];
+/** Throws a diagnostic naming every missing requested tool. */
+export declare function verifyEffectiveTools(promised: readonly string[], effective: readonly string[]): void;

package/assets/types/runtime/transport.d.ts

@@ -0,0 +1,143 @@
+import type { CanonicalJsonObject } from "./ask-contract-identity.ts";
+import type { AskLimitOutcome, AskStalledOutcome } from "./errors.ts";
+import type { AskOptions, SpawnOptions, ThinkingLevel } from "./types.ts";
+/**
+ * The one seam of the runtime (ticket 04). An AgentTransport represents a whole
+ * Agent and exchanges raw JSONL frames; it is the only place a process is known.
+ *
+ * Ask resolution and Lifecycle Events sit ABOVE this interface, so a replay
+ * implementation added later (ADR-0013) exercises the frame interpretation
+ * rather than bypassing it.
+ */
+/** One JSONL frame in either direction. Unknown `type`s must survive (ticket 01). */
+export type Frame = {
+    readonly type: string;
+    readonly [k: string]: unknown;
+};
+/** pi's full token usage for one Agent, as reported by `get_session_stats`. */
+export interface TokenBreakdown {
+    readonly input: number;
+    readonly output: number;
+    readonly cacheRead: number;
+    readonly cacheWrite: number;
+    readonly total: number;
+}
+/** Cost and usage read at Agent shutdown (ADR-0012). */
+export interface AgentStats {
+    /** Null when unavailable — e.g. killed before the first Ask completed. */
+    readonly tokens: TokenBreakdown | null;
+    readonly cost: number | null;
+}
+/** Recorded inputs used to explain an Ask-hash mismatch without changing identity. */
+export interface AskMarkerContext {
+    readonly prompt: string;
+    readonly spawn: Pick<SpawnOptions, "cwd" | "model" | "systemPrompt" | "thinking" | "appendSystemPrompt" | "tools" | "disallowedTools" | "skills" | "disallowedSkills" | "worktree">;
+    readonly ask: Pick<AskOptions, "maxTurns" | "maxToolCalls" | "maxDurationMs" | "idleMs" | "wrapUpPrompt"> & {
+        readonly outputSchema?: CanonicalJsonObject;
+        readonly maxSteers?: number;
+        readonly extractionPolicy?: string;
+    };
+}
+/** Opaque marker naming the Ask that subsequent frames belong to. */
+export interface AskMarker {
+    /** Monotonic per Agent, from 0. */
+    readonly index: number;
+    /** sha256 of prompt, spawn options, soft Ask behavior, and an optional output contract. */
+    readonly hash: string;
+    /** Canonical structured-output contract, present only for schema-bearing Asks. */
+    readonly outputSchema?: CanonicalJsonObject;
+    /** Explicit structured-output correction bound; omission remains distinct from a default. */
+    readonly maxSteers?: number;
+    /** Structured-output extraction behavior identifier. */
+    readonly extractionPolicy?: string;
+    /** Definition identity for Cassette diagnostics; never participates in the hash. */
+    readonly definitionName?: string;
+    /** Hash inputs retained only for definition-spawned Ask divergence diagnostics. */
+    readonly context?: AskMarkerContext;
+}
+/** Compact Cassette result for a surfaced structured-output exhaustion. */
+export interface AskInvalidOutputPlayback {
+    readonly kind: "invalid_output";
+    readonly steeringEfforts: number;
+}
+/** Presence identifies Cassette playback, including recorded successful Asks. */
+export interface AskPlayback {
+    /** Limit outcome recorded for this Ask, if it rejected with ASK_LIMIT. */
+    readonly limit?: AskLimitOutcome;
+    /** Stalled outcome recorded for this Ask, if it rejected with ASK_STALLED. */
+    readonly stalled?: AskStalledOutcome;
+    /** Invalid structured-output result recorded for this Ask, if it surfaced. */
+    readonly outcome?: AskInvalidOutputPlayback;
+    /** Whether recorded correction history has an abort settlement after final text. */
+    readonly awaitsAbortSettlement?: true;
+}
+/** One Agent, as the layer above sees it. */
+export interface AgentTransport {
+    /** Resolved model id from the startup `get_state` round-trip (ticket 03). */
+    readonly model: string;
+    /** Write one frame. Safe immediately after open: pi buffers stdin (ticket 01). */
+    send(frame: Frame): void;
+    /** Every frame from the Agent, in arrival order. Ends when the Agent is gone. */
+    frames(): AsyncIterable<Frame>;
+    /**
+     * Begins one Ask. Live transports return undefined; replay transports return
+     * playback metadata even when the recorded Ask succeeded.
+     */
+    beginAsk(marker: AskMarker): AskPlayback | undefined;
+    /** Reports surfaced live outcomes; replay ignores completion. */
+    finishAsk(outcome?: AskLimitOutcome, stalled?: AskStalledOutcome, invalidOutput?: AskInvalidOutputPlayback): void;
+    /**
+     * Shut the Agent down and report its cost. Idempotent.
+     * Owns the whole reap contract, so nothing above this interface knows what a
+     * signal is (ticket 02).
+     */
+    close(): Promise<AgentStats>;
+}
+/** Everything needed to open one Agent. */
+export interface OpenOptions {
+    /** Base cwd when requesting a worktree; resolved cwd after the wrapper opens it. */
+    readonly cwd: string;
+    readonly name: string;
+    /** Deterministic request for an isolated worktree; stripped before inner open. */
+    readonly worktree?: true;
+    readonly model?: string;
+    readonly systemPrompt?: string;
+    /** Process-start discovery policy; true restores pi's normal discovery, omission or false is hermetic. */
+    readonly inherit?: boolean;
+    /** Deterministic process-start thinking level; omission preserves pi's default. */
+    readonly thinking?: ThinkingLevel;
+    /** Deterministic process-start text appended to pi's system prompt. */
+    readonly appendSystemPrompt?: string;
+    /** Tool allowlist; an empty list disables all tools. */
+    readonly tools?: readonly string[];
+    /** Tool denylist, applied by pi after the allowlist. */
+    readonly disallowedTools?: readonly string[];
+    /** Skill allowlist by discovered name; identity only, never emitted as argv paths. */
+    readonly skills?: readonly string[];
+    /** Skill denylist by discovered name; identity only, never emitted as argv paths. */
+    readonly disallowedSkills?: readonly string[];
+    /** Resolved SKILL.md paths, injected only by the live restriction wrapper. */
+    readonly resolvedSkillPaths?: readonly string[];
+    /** Absolute launch-ready extension paths resolved above the seam, emitted as repeated `-e` flags. */
+    readonly resolvedExtensionPaths?: readonly string[];
+    /** Session storage directory. Used by the e2e suite to stay out of ~/.pi (ticket 06). */
+    readonly sessionDir?: string;
+    /** Resumes an existing pi session, translated to `--session <path>`. */
+    readonly sessionFile?: string;
+}
+/** Nondeterministic worktree identity resolved below the transport seam. */
+export interface WorktreeResolution {
+    readonly cwd: string;
+    readonly branch: string;
+}
+/** Startup facts a factory may report without widening AgentTransport. */
+export interface TransportStartup {
+    readonly sessionFile?: string;
+    readonly worktree?: WorktreeResolution;
+}
+/** Receives startup facts after a successful factory open. */
+export type TransportStartupObserver = (startup: TransportStartup) => void;
+/** How the layer above obtains transports. Swapped wholesale for replay. */
+export interface TransportFactory {
+    open(options: OpenOptions, observeStartup?: TransportStartupObserver): Promise<AgentTransport>;
+}

package/assets/types/runtime/types.d.ts

@@ -0,0 +1,120 @@
+import type { Static, TSchema } from "typebox";
+/** pi's supported thinking levels. */
+export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+/** Options for spawning one Agent (ADR-0001, ADR-0009, ADR-0026). */
+export interface SpawnOptions {
+    /** Working directory. Defaults to the Orchestrator's cwd. */
+    readonly cwd?: string;
+    /** Model pattern, e.g. "anthropic/claude-haiku-4". Unset inherits the user's default. */
+    readonly model?: string;
+    /** Replaces the default system prompt (`pi --system-prompt`). */
+    readonly systemPrompt?: string;
+    /** Sets pi's thinking level; omission preserves pi's default. */
+    readonly thinking?: ThinkingLevel;
+    /** Appends text to pi's system prompt (`pi --append-system-prompt`). */
+    readonly appendSystemPrompt?: string;
+    /**
+     * Restores pi discovery. Omission or false selects ADR-0026's hermetic baseline.
+     */
+    readonly inherit?: boolean;
+    /**
+     * Explicit pi extensions layer over either ADR-0026 baseline. Relative entries
+     * resolve from the Orchestration Program file; each becomes `pi -e <path>`.
+     */
+    readonly extensions?: readonly string[];
+    /**
+     * Tool allowlist layered over the ADR-0026 baseline; omission is tool-free when hermetic.
+     * `disallowedTools` applies last. A non-empty surviving allowlist is verified after startup;
+     * a missing promised name rejects spawn.
+     */
+    readonly tools?: readonly string[];
+    /**
+     * Tool denylist applied last under ADR-0026; `['yaag_run']` prevents nested yaag Runs.
+     * Denying an absent tool is inert and is not presence-validated.
+     */
+    readonly disallowedTools?: readonly string[];
+    /**
+     * Skill-name allowlist, not filesystem paths, layered over the ADR-0026 baseline.
+     * Omission is skill-free when hermetic; `disallowedSkills` applies last. Unknown requested
+     * names reject spawn.
+     */
+    readonly skills?: readonly string[];
+    /** Skill-name denylist discovered from pi and applied last (ADR-0026). */
+    readonly disallowedSkills?: readonly string[];
+    /** Log and event label. Defaults to a1, a2, …; duplicate names are suffixed. */
+    readonly name?: string;
+    /** Request a fresh Git worktree. The requested cwd remains the base until spawn resolves. */
+    readonly worktree?: boolean;
+}
+/** Topology-only fields that may change when spawning an Agent Definition. */
+export interface SpawnOverrides {
+    /** Log and event label. Defaults to the definition's name; duplicates are suffixed. */
+    readonly name?: string;
+    /** Working directory. Defaults to the Orchestrator's cwd. */
+    readonly cwd?: string;
+    /** Request a fresh Git worktree. */
+    readonly worktree?: boolean;
+}
+/**
+ * Options for one Ask (ADR-0003).
+ *
+ * Soft limits trip at their configured count: turns are `turn_start` frames and
+ * tool calls are `tool_execution_start` frames between `agent_start` and
+ * `agent_settled`; duration is wall time from prompt send. A trip steers the
+ * Agent, permits one further turn (or a fixed duration grace), then aborts and
+ * rejects with `ASK_LIMIT` if it has not settled. This leaves the Handle alive.
+ * `timeoutMs` is independent: it kills the Agent and rejects with `ASK_TIMEOUT`.
+ */
+export interface AskOptions {
+    /** Reject and kill the Agent if it has not settled in time. Unset = no bound. */
+    readonly timeoutMs?: number;
+    /** Soft budget of `turn_start` frames between `agent_start` and `agent_settled`. */
+    readonly maxTurns?: number;
+    /** Soft budget of `tool_execution_start` frames between `agent_start` and `agent_settled`. */
+    readonly maxToolCalls?: number;
+    /** Soft wall-clock budget in milliseconds, measured from prompt send. */
+    readonly maxDurationMs?: number;
+    /**
+     * Maximum silence in milliseconds: rejects with `ASK_STALLED` when no frame
+     * arrives for this span. Complementary to `maxDurationMs` (silence vs.
+     * trickle) and separate from `timeoutMs`, which always kills. Unset disables
+     * idle detection (ADR-0020).
+     */
+    readonly idleMs?: number;
+    /** Per-Ask replacement for the runtime's wrap-up steering message. */
+    readonly wrapUpPrompt?: string;
+}
+/** Ask options that require a schema and preserve its inferred successful result. */
+export interface StructuredAskOptions<Schema extends TSchema> extends AskOptions {
+    /** TypeBox schema that changes successful Ask resolution from text to a parsed value. */
+    readonly outputSchema: Schema;
+    /** Maximum corrective steering efforts for this Ask; defaults to 3 when omitted. */
+    readonly maxSteers?: number;
+}
+/**
+ * A handle to one long-lived Agent.
+ * ADR-0003: `ask()` is the only conversational verb; everything else is data.
+ */
+export interface Handle {
+    /** Stable identity, used in every Lifecycle Event and log line. */
+    readonly name: string;
+    /** Resolved absolute working directory; a worktree's actual cwd after spawn resolves. */
+    readonly cwd: string;
+    /** Fresh branch for a worktree Agent; undefined for ordinary Agents. */
+    readonly branch: string | undefined;
+    /** Model id as reported by the Agent's own `get_state` — not the requested pattern. */
+    readonly model: string;
+    /**
+     * Sends a prompt and resolves after the Agent's turn settles.
+     *
+     * Schema-free calls resolve with the exact final assistant text. Calls with
+     * `outputSchema` resolve with the extracted, TypeBox-validated value. Rejects
+     * with a YaagError for a failed or empty turn, timeout, `ASK_LIMIT`, or dead
+     * Agent; invalid structured output rejects recoverably with
+     * `ASK_INVALID_OUTPUT` after at most `maxSteers` (default 3) in-Ask
+     * correction efforts and an abort settlement. These recoverable outcomes
+     * leave the Handle reusable. A concurrent call rejects with `AGENT_BUSY`.
+     */
+    ask<Schema extends TSchema>(prompt: string, options: StructuredAskOptions<Schema>): Promise<Static<Schema>>;
+    ask(prompt: string, options?: AskOptions): Promise<string>;
+}

package/assets/types/runtime/validation-errors.d.ts

@@ -0,0 +1,3 @@
+import type { TLocalizedValidationError } from "typebox/error";
+/** Formats TypeBox errors with stable JSON-path prefixes for public diagnostics. */
+export declare function formatValidationErrors(value: unknown, errors: Iterable<TLocalizedValidationError>): readonly string[];

package/assets/types/runtime/wire-constants.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Cap on `ask_start.promptGist` characters (ticket 09). Shared so producers
+ * and observers agree on how much prompt ever rides the wire — the full
+ * prompt never does; `promptChars` carries its true length.
+ */
+export declare const PROMPT_GIST_MAX_CHARS = 160;
+/** Cap on the one-line argument gist carried by `ask_activity` tool observations. */
+export declare const TOOL_ARGS_GIST_MAX_CHARS = 120;
+/** Delay before a live Ask's pending assistant output tail is emitted. */
+export declare const ASK_OUTPUT_FLUSH_INTERVAL_MS = 250;
+/** Maximum UTF-8 payload bytes in one coalesced live Ask output batch. */
+export declare const ASK_OUTPUT_MAX_BYTES: number;
+/** Cap on the one-line `activityGist` carried by a `node_update` event. */
+export declare const NODE_GIST_MAX_CHARS = 120;
+/** Maximum Nested Nodes the Summary keeps per Agent; past it, exited nodes prune oldest-first. */
+export declare const AGENT_NODE_TABLE_MAX = 64;
+/** Prefix marking that the oldest pending Ask output was dropped to fit the wire cap. */
+export declare const ASK_OUTPUT_TRUNCATION_MARKER = "[\u2026output truncated\u2026]";

package/assets/types/runtime/worktree-transport.d.ts

@@ -0,0 +1,9 @@
+import type { TransportFactory } from "./transport.ts";
+/**
+ * Creates an isolated Git worktree before opening flagged Agents.
+ *
+ * Refuses non-repositories and dirty base trees with `WORKTREE_REFUSED`, before
+ * opening `inner`. Created worktrees and branches are deliberately never
+ * removed: yaag does not own the user's work after creation (ADR-0007).
+ */
+export declare function worktreeTransport(inner: TransportFactory): TransportFactory;

package/assets/types/typebox/build/compile/code.d.mts

@@ -0,0 +1,12 @@
+import { type TProperties, type TSchema } from '../type/index.mjs';
+import { type TExternal } from '../schema/index.mjs';
+export interface CodeResult {
+    /** External Variables  */
+    External: TExternal;
+    /** Generated Esm module. */
+    Code: string;
+}
+/** Creates a standalone ESM validation module for the given type. */
+export declare function Code<Type extends TSchema>(type: Type): CodeResult;
+/** Creates a standalone ESM validation module for the given type. */
+export declare function Code<Context extends TProperties, Type extends TSchema>(context: Context, type: Type): CodeResult;

package/assets/types/typebox/build/compile/compile.d.mts

@@ -0,0 +1,6 @@
+import { type TProperties, type TSchema } from '../type/index.mjs';
+import { Validator } from './validator.mjs';
+/** Compiles a type into a high performance Validator */
+export declare function Compile<const Type extends TSchema, Result extends Validator = Validator<{}, Type>>(type: Type): Result;
+/** Compiles a type into a high performance Validator */
+export declare function Compile<Context extends TProperties, const Type extends TSchema, Result extends Validator = Validator<Context, Type>>(context: Context, type: Type): Result;

package/assets/types/typebox/build/compile/index.d.mts

@@ -0,0 +1,8 @@
+export * from './code.mjs';
+export * from './compile.mjs';
+export * from './validator.mjs';
+import { Code } from './code.mjs';
+import { Compile } from './compile.mjs';
+import { Validator } from './validator.mjs';
+export { Code, Compile, Validator };
+export default Compile;

package/assets/types/typebox/build/compile/validator.d.mts

@@ -0,0 +1,35 @@
+import { type TLocalizedValidationError } from '../error/index.mjs';
+import { type StaticDecode, type StaticEncode, type TProperties, type TSchema } from '../type/index.mjs';
+export declare class Validator<Context extends TProperties = TProperties, Type extends TSchema = TSchema, Encode extends unknown = StaticEncode<Type, Context>, Decode extends unknown = StaticDecode<Type, Context>> {
+    private readonly hasCodec;
+    private readonly buildResult;
+    private readonly evaluateResult;
+    /** Constructs a Validator. */
+    constructor(context: Context, type: Type);
+    /** Returns true if this Validator is using JIT acceleration. */
+    IsAccelerated(): boolean;
+    /** Returns the Context for this validator. */
+    Context(): Context;
+    /** Returns the underlying Type used to construct this Validator. */
+    Type(): Type;
+    /** Returns the generated code for this validator. */
+    Code(): string;
+    /** Performs a type-guard check on the provided value. */
+    Check(value: unknown): value is Encode;
+    /** Validates a value and returns it. Will throw if invalid. */
+    Parse(value: unknown): Encode;
+    /** Inspects a value and returns a detailed list of validation errors. */
+    Errors(value: unknown): TLocalizedValidationError[];
+    /** Cleans a value using the Validator type. */
+    Clean(value: unknown): unknown;
+    /** Converts a value using the Validator type. */
+    Convert(value: unknown): unknown;
+    /** Creates a value using the Validator type. */
+    Create(): Encode;
+    /** Creates defaults using the Validator type. */
+    Default(value: unknown): unknown;
+    /** Decodes a value */
+    Decode(value: unknown): Decode;
+    /** Encodes a value */
+    Encode(value: unknown): Encode;
+}

package/assets/types/typebox/build/error/errors.d.mts

@@ -0,0 +1,208 @@
+export type TValidationError = TAdditionalPropertiesError | TAnyOfError | TBooleanError | TConstError | TContainsError | TDependenciesError | TDependentRequiredError | TEnumError | TExclusiveMaximumError | TExclusiveMinimumError | TFormatError | TIfError | TMaximumError | TMaxItemsError | TMaxLengthError | TMaxPropertiesError | TMinimumError | TMinItemsError | TMinLengthError | TMinPropertiesError | TMultipleOfError | TNotError | TOneOfError | TPatternError | TPropertyNamesError | TRefineError | TRequiredError | TTypeError | TUnevaluatedItemsError | TUnevaluatedPropertiesError | TUniqueItemsError;
+export declare function IsValidationError(value: unknown): value is TValidationError;
+export type TLocalizedValidationError = TValidationError & {
+    message: string;
+};
+export declare function IsLocalizedValidationError(value: unknown): value is TLocalizedValidationError;
+export type TLocalizedValidationMessageCallback = (error: TValidationError) => string;
+export interface TValidationErrorBase {
+    keyword: string;
+    schemaPath: string;
+    instancePath: string;
+    params: object;
+}
+export interface TAdditionalPropertiesError extends TValidationErrorBase {
+    keyword: 'additionalProperties';
+    params: {
+        additionalProperties: string[];
+    };
+}
+export interface TAnyOfError extends TValidationErrorBase {
+    keyword: 'anyOf';
+    params: {};
+}
+export interface TBooleanError extends TValidationErrorBase {
+    keyword: 'boolean';
+    params: {};
+}
+export interface TConstError extends TValidationErrorBase {
+    keyword: 'const';
+    params: {
+        allowedValue: unknown;
+    };
+}
+export interface TContainsError extends TValidationErrorBase {
+    keyword: 'contains';
+    params: {
+        minContains: number;
+        maxContains?: number;
+    };
+}
+export interface TDependenciesError extends TValidationErrorBase {
+    keyword: 'dependencies';
+    params: {
+        property: string;
+        dependencies: string[];
+    };
+}
+export interface TDependentRequiredError extends TValidationErrorBase {
+    keyword: 'dependentRequired';
+    params: {
+        property: string;
+        dependencies: string[];
+    };
+}
+export interface TEnumError extends TValidationErrorBase {
+    keyword: 'enum';
+    params: {
+        allowedValues: unknown[];
+    };
+}
+export interface TExclusiveMaximumError extends TValidationErrorBase {
+    keyword: 'exclusiveMaximum';
+    params: {
+        comparison: '<';
+        limit: number | bigint;
+    };
+}
+export interface TExclusiveMinimumError extends TValidationErrorBase {
+    keyword: 'exclusiveMinimum';
+    params: {
+        comparison: '>';
+        limit: number | bigint;
+    };
+}
+export interface TFormatError extends TValidationErrorBase {
+    keyword: 'format';
+    params: {
+        format: string;
+    };
+}
+export interface TIfError extends TValidationErrorBase {
+    keyword: 'if';
+    params: {
+        failingKeyword: 'then' | 'else';
+    };
+}
+export interface TMaximumError extends TValidationErrorBase {
+    keyword: 'maximum';
+    params: {
+        comparison: '<=';
+        limit: number | bigint;
+    };
+}
+export interface TMaxItemsError extends TValidationErrorBase {
+    keyword: 'maxItems';
+    params: {
+        limit: number;
+    };
+}
+export interface TMaxLengthError extends TValidationErrorBase {
+    keyword: 'maxLength';
+    params: {
+        limit: number;
+    };
+}
+export interface TMaxPropertiesError extends TValidationErrorBase {
+    keyword: 'maxProperties';
+    params: {
+        limit: number;
+    };
+}
+export interface TMinimumError extends TValidationErrorBase {
+    keyword: 'minimum';
+    params: {
+        comparison: '>=';
+        limit: number | bigint;
+    };
+}
+export interface TMinItemsError extends TValidationErrorBase {
+    keyword: 'minItems';
+    params: {
+        limit: number;
+    };
+}
+export interface TMinLengthError extends TValidationErrorBase {
+    keyword: 'minLength';
+    params: {
+        limit: number;
+    };
+}
+export interface TMinPropertiesError extends TValidationErrorBase {
+    keyword: 'minProperties';
+    params: {
+        limit: number;
+    };
+}
+export interface TMultipleOfError extends TValidationErrorBase {
+    keyword: 'multipleOf';
+    params: {
+        multipleOf: number | bigint;
+    };
+}
+export interface TMinimumError extends TValidationErrorBase {
+    keyword: 'minimum';
+    params: {
+        comparison: '>=';
+        limit: number | bigint;
+    };
+}
+export interface TNotError extends TValidationErrorBase {
+    keyword: 'not';
+    params: {};
+}
+export interface TOneOfError extends TValidationErrorBase {
+    keyword: 'oneOf';
+    params: {
+        passingSchemas: number[];
+    };
+}
+export interface TPatternError extends TValidationErrorBase {
+    keyword: 'pattern';
+    params: {
+        pattern: string | RegExp;
+    };
+}
+export interface TPropertyNamesError extends TValidationErrorBase {
+    keyword: 'propertyNames';
+    params: {
+        propertyNames: string[];
+    };
+}
+export interface TRefineError extends TValidationErrorBase {
+    keyword: '~refine';
+    params: {
+        index: number;
+        message: string;
+    };
+}
+export interface TRequiredError extends TValidationErrorBase {
+    keyword: 'required';
+    params: {
+        requiredProperties: string[];
+    };
+}
+export interface TTypeError extends TValidationErrorBase {
+    keyword: 'type';
+    params: {
+        type: string | string[];
+    };
+}
+export interface TUnevaluatedItemsError extends TValidationErrorBase {
+    keyword: 'unevaluatedItems';
+    params: {
+        unevaluatedItems: number[];
+    };
+}
+export interface TUnevaluatedPropertiesError extends TValidationErrorBase {
+    keyword: 'unevaluatedProperties';
+    params: {
+        unevaluatedProperties: PropertyKey[];
+    };
+}
+export interface TUniqueItemsError extends TValidationErrorBase {
+    keyword: 'uniqueItems';
+    params: {
+        duplicateItems: number[];
+    };
+}

package/assets/types/typebox/build/error/index.d.mts

@@ -0,0 +1 @@
+export * from './errors.mjs';

package/assets/types/typebox/build/format/_idna.d.mts

@@ -0,0 +1,2 @@
+export declare function IsIdnLabel(value: string): boolean;
+export declare function IsLabel(value: string): boolean;

package/assets/types/typebox/build/format/_puny.d.mts

@@ -0,0 +1 @@
+export declare function Decode(value: string): string;

package/assets/types/typebox/build/format/_registry.d.mts

@@ -0,0 +1,15 @@
+export type TFormatCheckFunction = (value: string) => boolean;
+/** Clears all entries */
+export declare function Clear(): void;
+/** Returns format entries in this registry */
+export declare function Entries(): [string, TFormatCheckFunction][];
+/** Sets a format */
+export declare function Set(format: string, check: TFormatCheckFunction): void;
+/** Returns true if the registry has this format */
+export declare function Has(format: string): boolean;
+/** Gets a format or undefined if not exists */
+export declare function Get(format: string): TFormatCheckFunction | undefined;
+/** Tests a value against a format, if the format is not registered, true */
+export declare function Test(format: string, value: string): boolean;
+/** Resets all formats to defaults */
+export declare function Reset(): void;

package/assets/types/typebox/build/format/date.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Returns true if the value is a ISO8601 Date component string
+ * @source ajv-formats
+ * @example `2020-12-12`
+ */
+export declare function IsDate(value: string): boolean;

package/assets/types/typebox/build/format/date_time.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Returns true if the value is a ISO8601 DateTime string
+ * @source ajv-formats
+ * @example `2020-12-12T20:20:40+00:00`
+ */
+export declare function IsDateTime(value: string, strictTimeZone?: boolean): boolean;

package/assets/types/typebox/build/format/duration.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Returns true if the value is a valid ISO-8601 duration.
+ * @specification https://tools.ietf.org/html/rfc3339
+ */
+export declare function IsDuration(value: string): boolean;