@oh-my-pi/pi-coding-agent 17.2.5 → 17.2.7

package/src/tools/hub/launch.ts

@@ -10,7 +10,7 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
 import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
-import { daemonClientForProject } from "../../launch/client";
+import { type DaemonBrokerClient, DaemonBrokerRejectedError, daemonClientForProject } from "../../launch/client";
 import type { DaemonOperation, DaemonRpcResult, DaemonSnapshot, DaemonSpec, DaemonState } from "../../launch/protocol";
 import { renderTerminalOutputIsolated } from "../../launch/terminal-output-worker-client";
 import type { Theme, ThemeColor } from "../../modes/theme/theme";
@@ -35,6 +35,81 @@ import {
 import { styleTerminalRow } from "../terminal-output";
 import { ToolError } from "../tool-errors";
 
+interface CompletionRegistration {
+	inFlight: number;
+	retained: boolean;
+	active: boolean;
+	cleanup: (preservePending?: boolean) => void;
+}
+
+interface CompletionLease {
+	retain: () => void;
+	reject: (preservePending?: boolean) => void;
+	hasConcurrentRequest: () => boolean;
+}
+
+const completionRegistrations = new WeakMap<
+	ToolSession,
+	Map<DaemonBrokerClient, Map<string, CompletionRegistration>>
+>();
+
+function registerCompletionSink(
+	session: ToolSession,
+	client: DaemonBrokerClient,
+	owner: string,
+): CompletionLease | undefined {
+	if (!session.queueLaunchCompletion) return undefined;
+	let clients = completionRegistrations.get(session);
+	if (!clients) {
+		clients = new Map();
+		completionRegistrations.set(session, clients);
+	}
+	let owners = clients.get(client);
+	if (!owners) {
+		owners = new Map();
+		clients.set(client, owners);
+	}
+	let registration = owners.get(owner);
+	if (!registration) {
+		const unregister = client.onCompletion(owner, notification => {
+			if (session.isDisposed?.()) throw new Error("Session disposed before launch completion delivery");
+			const delivery = session.queueLaunchCompletion?.(notification);
+			if (!delivery) throw new Error("Session cannot accept launch completion delivery");
+			return delivery;
+		});
+		let unregisterDispose: (() => void) | void;
+		let unregisterSessionChange: (() => void) | void;
+		const cleanup = (preservePending = false): void => {
+			if (!registration?.active) return;
+			registration.active = false;
+			unregister({ preservePending });
+			unregisterDispose?.();
+			unregisterSessionChange?.();
+			owners.delete(owner);
+			if (owners.size === 0) clients.delete(client);
+			if (clients.size === 0) completionRegistrations.delete(session);
+		};
+		registration = { inFlight: 0, retained: false, active: true, cleanup };
+		owners.set(owner, registration);
+		unregisterDispose = session.registerDisposeCallback?.(() => cleanup(true));
+		unregisterSessionChange = session.registerSessionChangeCallback?.(() => cleanup(true));
+	}
+	registration.inFlight++;
+	let settled = false;
+	const settle = (retain: boolean, preservePending = false): void => {
+		if (settled || !registration.active) return;
+		settled = true;
+		registration.inFlight--;
+		if (retain) registration.retained = true;
+		if (!registration.retained && registration.inFlight === 0) registration.cleanup(preservePending);
+	};
+	return {
+		retain: () => settle(true),
+		hasConcurrentRequest: () => registration.active && registration.inFlight > 1,
+		reject: preservePending => settle(false, preservePending),
+	};
+}
+
 /** Broker-facing launch parameters; the hub adapts its `ps` op to `list` before calling in. */
 export interface LaunchParams {
 	op: "start" | "list" | "logs" | "wait" | "send" | "stop" | "restart" | "describe";
@@ -321,11 +396,52 @@ export async function executeLaunch(
 	signal?: AbortSignal,
 ): Promise<AgentToolResult<LaunchToolDetails>> {
 	const client = await daemonClientForProject(session.cwd);
-	const result = await client.request(operationFor(params, session), signal);
-	return {
-		content: [{ type: "text", text: replaceTabs(toolContent(result, params)) }],
-		details: await toolDetails(result, params),
-	};
+	const operation = operationFor(params, session);
+	const owner = operation.op === "start" ? operation.owner : undefined;
+	const resumedOwner = params.op !== "start" ? (session.getSessionId?.() ?? undefined) : undefined;
+	const completionLease = owner
+		? registerCompletionSink(session, client, owner)
+		: resumedOwner
+			? registerCompletionSink(session, client, resumedOwner)
+			: undefined;
+	try {
+		const result = await client.request(operation, signal);
+		const sessionOwner = session.getSessionId?.();
+		let resumedDaemonFound = false;
+		const daemons =
+			result.op === "list" ? result.daemons : "daemon" in result && result.daemon ? [result.daemon] : [];
+		for (const daemon of daemons) {
+			if (!daemon.owner || daemon.owner !== sessionOwner || TERMINAL_STATES[daemon.state]) continue;
+			resumedDaemonFound = true;
+			if (daemon.owner !== resumedOwner) registerCompletionSink(session, client, daemon.owner)?.retain();
+		}
+		if (params.op === "list" && resumedOwner && !resumedDaemonFound) completionLease?.reject(true);
+		else completionLease?.retain();
+		return {
+			content: [{ type: "text", text: replaceTabs(toolContent(result, params)) }],
+			details: await toolDetails(result, params),
+		};
+	} catch (error) {
+		if (error instanceof DaemonBrokerRejectedError && owner) {
+			if (completionLease?.hasConcurrentRequest()) {
+				completionLease.reject();
+			} else {
+				try {
+					const listed = await client.request({ op: "list" }, signal);
+					const ownerStillRunning =
+						listed.op === "list" &&
+						listed.daemons.some(daemon => daemon.owner === owner && !TERMINAL_STATES[daemon.state]);
+					if (ownerStillRunning) completionLease?.retain();
+					else completionLease?.reject(true);
+				} catch {
+					completionLease?.retain();
+				}
+			}
+		} else {
+			completionLease?.retain();
+		}
+		throw error;
+	}
 }
 
 // =============================================================================

package/src/tools/image-gen.ts

@@ -1,5 +1,6 @@
 import * as os from "node:os";
 import * as path from "node:path";
+import { type } from "@oh-my-pi/omptype";
 import { type ApiKey, type FetchImpl, getEnvApiKey, type Model, withAuth } from "@oh-my-pi/pi-ai";
 import { ProviderHttpError } from "@oh-my-pi/pi-ai/error";
 import {
@@ -20,7 +21,6 @@ import {
 	Snowflake,
 	untilAborted,
 } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
 import packageJson from "../../package.json" with { type: "json" };
 import { isAuthenticated, type ModelRegistry } from "../config/model-registry";
 import { settings } from "../config/settings";

package/src/tools/index.ts

@@ -16,6 +16,7 @@ import type { GoalModeState, GoalRuntime } from "../goals";
 import { GoalTool } from "../goals/tools/goal-tool";
 import type { HindsightSessionState } from "../hindsight/state";
 import type { LocalProtocolOptions } from "../internal-urls";
+import type { DaemonCompletionNotification } from "../launch/protocol";
 import { LspTool } from "../lsp";
 import type { MCPManager } from "../mcp";
 import type { MnemopiSessionState } from "../mnemopi/state";
@@ -155,6 +156,8 @@ export interface ToolSession {
 	additionalDirectories?: string[];
 	/** Whether UI is available */
 	hasUI: boolean;
+	/** Whether this session has begun disposal. */
+	isDisposed?: () => boolean;
 	/**
 	 * Suppress the spawn specialization/coordination advisory appended to `task`
 	 * results. Set by internal/programmatic callers (e.g. the commit agent's
@@ -380,6 +383,12 @@ export interface ToolSession {
 
 	/** Queue a hidden message to be injected at the next agent turn. */
 	queueDeferredMessage?(message: CustomMessage): void;
+	/** Queue a broker supervised-process completion for the owning session. */
+	queueLaunchCompletion?(notification: DaemonCompletionNotification): Promise<void>;
+	/** Register cleanup that runs when this session is disposed; returns a handle that removes the cleanup. */
+	registerDisposeCallback?(callback: () => void): (() => void) | void;
+	/** Register cleanup that runs when this ToolSession adopts a different session ID. */
+	registerSessionChangeCallback?(callback: () => void): (() => void) | void;
 	/** Queue late LSP diagnostics (arrived after an edit/write returned) to be shown
 	 *  in the transcript and delivered to the model at the next yield, like background
 	 *  job results. */

package/src/tools/inspect-image.ts

@@ -1,3 +1,4 @@
+import { type } from "@oh-my-pi/omptype";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { instrumentedCompleteSimple, resolveTelemetry } from "@oh-my-pi/pi-agent-core";
 import {
@@ -9,7 +10,6 @@ import {
 	type ToolExample,
 } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
 import { extractTextContent } from "../commit/utils";
 
 import {

package/src/tools/learn.ts

@@ -1,5 +1,5 @@
+import { type } from "@oh-my-pi/omptype";
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { type } from "arktype";
 import { sanitizeSkillName, writeManagedSkill } from "../autolearn/managed-skills";
 import { isNameClaimedByAuthoredSkill } from "../extensibility/skills";
 import { localBackend } from "../memory-backend/local-backend";

package/src/tools/manage-skill.ts

@@ -1,6 +1,6 @@
 import * as path from "node:path";
+import { type } from "@oh-my-pi/omptype";
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { type } from "arktype";
 import {
 	deleteManagedSkill,
 	getManagedSkillsDir,

package/src/tools/memory-edit.ts

@@ -1,5 +1,5 @@
+import { type } from "@oh-my-pi/omptype";
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { type } from "arktype";
 import memoryEditDescription from "../prompts/tools/memory-edit.md" with { type: "text" };
 import type { ToolSession } from ".";
 

package/src/tools/memory-recall.ts

@@ -1,6 +1,6 @@
+import { type } from "@oh-my-pi/omptype";
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { logger, untilAborted } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
 import { formatCurrentTime, formatMemories } from "../hindsight/content";
 import recallDescription from "../prompts/tools/recall.md" with { type: "text" };
 import type { ToolSession } from ".";

package/src/tools/memory-reflect.ts

@@ -1,6 +1,6 @@
+import { type } from "@oh-my-pi/omptype";
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { logger, untilAborted } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
 import { ensureBankExists } from "../hindsight/bank";
 import reflectDescription from "../prompts/tools/reflect.md" with { type: "text" };
 import type { ToolSession } from ".";

package/src/tools/memory-retain.ts

@@ -1,5 +1,5 @@
+import { type } from "@oh-my-pi/omptype";
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { type } from "arktype";
 import retainDescription from "../prompts/tools/retain.md" with { type: "text" };
 import type { ToolSession } from ".";
 

package/src/tools/read.ts

@@ -3,6 +3,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { formatHashlineHeader, formatNumberedLine, formatNumberedLines } from "@oh-my-pi/hashline";
+import { type } from "@oh-my-pi/omptype";
 import type {
 	AgentTool,
 	AgentToolContext,
@@ -25,7 +26,6 @@ import {
 	readImageMetadata,
 	untilAborted,
 } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
 import { LRUCache } from "lru-cache/raw";
 import {
 	canonicalSnapshotKey,

package/src/tools/security-scan.ts

@@ -1,5 +1,5 @@
+import { type } from "@oh-my-pi/omptype";
 import type { AgentTool, AgentToolResult, ToolTier } from "@oh-my-pi/pi-agent-core";
-import { type } from "arktype";
 import securityScanDescription from "../prompts/tools/security-scan.md" with { type: "text" };
 import { selectSecurityAccount } from "../security/auth";
 import {

package/src/tools/todo.ts

@@ -1,9 +1,9 @@
+import { type } from "@oh-my-pi/omptype";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ToolExample } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { isRecord, prompt, sanitizeText } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
 import chalk from "chalk";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";

package/src/tools/tts.ts

@@ -3,10 +3,10 @@
 // backend (Kokoro-82M via kokoro-js on the shared ONNX worker) is layered on behind
 // the `providers.tts` switch.
 
+import { type } from "@oh-my-pi/omptype";
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { type ApiKey, withAuth } from "@oh-my-pi/pi-ai";
 import { ProviderHttpError } from "@oh-my-pi/pi-ai/error";
-import { type } from "arktype";
 import { settings } from "../config/settings";
 import type { CustomTool, CustomToolContext } from "../extensibility/custom-tools/types";
 import { ohMyPiXAIUserAgent, resolveXAIHttpCredentials } from "../lib/xai-http";

package/src/tools/vibe.ts

@@ -10,11 +10,12 @@
  * terminal), and wait/list draw the "TV wall" — one live screen per worker,
  * stacked, each showing its tool calls and streamed text as it works.
  */
+
+import { type } from "@oh-my-pi/omptype";
 import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { shimmerEnabled, shimmerText } from "../modes/theme/shimmer";
 import type { Theme } from "../modes/theme/theme";

package/src/tools/write.ts

@@ -3,6 +3,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 
 import { formatHashlineHeader, stripHashlinePrefixes } from "@oh-my-pi/hashline";
+import { type } from "@oh-my-pi/omptype";
 import type {
 	AgentTool,
 	AgentToolContext,
@@ -12,7 +13,6 @@ import type {
 } from "@oh-my-pi/pi-agent-core";
 import { type Component, Text } from "@oh-my-pi/pi-tui";
 import { isEnoent, isRecord, prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
 
 import { canonicalSnapshotKey, getFileSnapshotStore } from "../edit/file-snapshot-store";
 import { normalizeToLF } from "../edit/normalize";

package/src/web/search/index.ts

@@ -4,10 +4,11 @@
  * Single tool supporting Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, Codex, Tavily, Kagi, Z.AI, SearXNG, and Synthetic
  * providers with provider-specific parameters exposed conditionally.
  */
+
+import { type } from "@oh-my-pi/omptype";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { AuthStorage } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { type } from "arktype";
 import { ModelRegistry } from "../../config/model-registry";
 import { settings } from "../../config/settings";
 import type { CustomTool, CustomToolContext, RenderResultOptions } from "../../extensibility/custom-tools/types";

package/dist/types/config/file-lock.d.ts

@@ -1,29 +0,0 @@
-export interface FileLockOptions {
-    staleMs?: number;
-    retries?: number;
-    retryDelayMs?: number;
-}
-interface LockInfo {
-    pid: number;
-    timestamp: number;
-    token: string;
-}
-declare function getLockPath(filePath: string): string;
-declare function readLockInfo(lockPath: string): Promise<LockInfo | null>;
-declare function isLockStale(lockPath: string, staleMs: number): Promise<boolean>;
-declare function tryAcquireLock(lockPath: string): Promise<string | null>;
-declare function releaseLock(lockPath: string, expectedToken?: string): Promise<void>;
-export declare function withFileLock<T>(filePath: string, fn: () => Promise<T>, options?: FileLockOptions): Promise<T>;
-/**
- * Test-only handles for the internal lock primitives. These are NOT part of
- * the public API — they exist so the contract tests can validate token-keyed
- * release semantics and the mkdir-race window without re-implementing them.
- */
-export declare const __internalsForTesting: {
-    tryAcquireLock: typeof tryAcquireLock;
-    releaseLock: typeof releaseLock;
-    readLockInfo: typeof readLockInfo;
-    isLockStale: typeof isLockStale;
-    getLockPath: typeof getLockPath;
-};
-export {};

package/dist/types/extensibility/typebox.d.ts

@@ -1,181 +0,0 @@
-/**
- * Minimal `@sinclair/typebox` runtime compatibility shim.
- *
- * Historically the coding agent injected the real `@sinclair/typebox` (~5MB
- * dependency) into extensions, hooks, custom tools, and custom commands so
- * they could author parameter schemas as `Type.Object({ name: Type.String() })`.
- *
- * This module provides the subset those integrations depend on:
- *
- *   - TypeBox-style `Type.*` builders.
- *   - Runtime validation through `schema.safeParse(input)` and `schema.__validator(input)`.
- *   - Enumerable JSON Schema keywords so `{ ...schema }`, `JSON.stringify(schema)`,
- *     and `toolWireSchema({ parameters: schema })` all see the same schema.
- *
- * Internal validator fields and methods are intentionally non-enumerable. The
- * object should look like JSON Schema at every serialization/wire boundary and
- * like a small validator at runtime.
- */
-export type TSchema = ArkSchema;
-export type Static<T extends ArkSchema> = T["__infer"];
-export type TAny = ArkSchema;
-export type TUnknown = ArkSchema;
-export type TNever = ArkSchema;
-export type TNull = ArkSchema;
-export type TString = ArkSchema;
-export type TNumber = ArkSchema;
-export type TInteger = ArkSchema;
-export type TBoolean = ArkSchema;
-export type TLiteral<_V extends string | number | boolean> = ArkSchema;
-export type TArray<_E extends ArkSchema> = ArkSchema;
-export type TObject<_P extends Record<string, ArkSchema> = Record<string, ArkSchema>> = ArkSchema;
-export type TOptional<_E extends ArkSchema> = ArkSchema;
-export type TUnion<_T extends readonly ArkSchema[] = readonly ArkSchema[]> = ArkSchema;
-export type TEnum<_T extends readonly (string | number)[] = readonly (string | number)[]> = ArkSchema;
-export type TRecord<_K extends ArkSchema, _V extends ArkSchema> = ArkSchema;
-/** TypeBox-compatible wrapper for raw JSON Schema documents. */
-export type TUnsafe<_T = unknown> = ArkSchema;
-declare const VALIDATION_FAILURE: unique symbol;
-interface ValidationFailure {
-    message: string;
-    readonly [VALIDATION_FAILURE]: true;
-}
-interface SafeParseSuccess {
-    success: true;
-    data: unknown;
-}
-interface SafeParseFailure {
-    success: false;
-    error: ValidationFailure;
-}
-/**
- * JSON-Schema-shaped object with non-enumerable runtime helpers.
- * Validators return the validated data or a marked `{ message }` failure.
- */
-interface ArkSchema {
-    __validator: (data: unknown) => unknown;
-    __metadata?: Record<string, unknown>;
-    __optional?: true;
-    __properties?: Record<string, ArkSchema>;
-    __additionalProperties?: boolean | ArkSchema;
-    __infer?: unknown;
-    __inner?: ArkSchema;
-    safeParse(input: unknown): SafeParseSuccess | SafeParseFailure;
-    toJSON(): Record<string, unknown>;
-    [key: string]: unknown;
-}
-interface Meta {
-    title?: string;
-    description?: string;
-    default?: unknown;
-    examples?: unknown[];
-    [key: string]: unknown;
-}
-interface StringOpts extends Meta {
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-    format?: string;
-}
-interface NumberOpts extends Meta {
-    minimum?: number;
-    maximum?: number;
-    exclusiveMinimum?: number;
-    exclusiveMaximum?: number;
-    multipleOf?: number;
-}
-interface ArrayOpts extends Meta {
-    minItems?: number;
-    maxItems?: number;
-    uniqueItems?: boolean;
-}
-interface ObjectOpts extends Meta {
-    /**
-     * TypeBox default: extra keys are preserved. Set `false` to reject unknowns,
-     * `true` to allow any, or a schema to validate them.
-     */
-    additionalProperties?: boolean | ArkSchema;
-}
-declare function tString(opts?: StringOpts): ArkSchema;
-declare function tNumber(opts?: NumberOpts): ArkSchema;
-declare function tInteger(opts?: NumberOpts): ArkSchema;
-declare function tBoolean(opts?: Meta): ArkSchema;
-declare function tNull(opts?: Meta): ArkSchema;
-declare function tAny(opts?: Meta): ArkSchema;
-declare function tUnknown(opts?: Meta): ArkSchema;
-declare function tNever(opts?: Meta): ArkSchema;
-declare function tLiteral<V extends string | number | boolean>(value: V, opts?: Meta): ArkSchema;
-declare function tUnion<T extends readonly ArkSchema[]>(schemas: T, opts?: Meta): ArkSchema;
-declare function tIntersect(schemas: readonly ArkSchema[], opts?: Meta): ArkSchema;
-declare function tEnum<T extends Record<string, string | number> | readonly (string | number)[]>(values: T, opts?: Meta): ArkSchema;
-declare function tArray<E extends ArkSchema>(item: E, opts?: ArrayOpts): ArkSchema;
-declare function tTuple(items: readonly ArkSchema[], opts?: Meta): ArkSchema;
-declare function tObject<P extends Record<string, ArkSchema>>(properties: P, opts?: ObjectOpts): ArkSchema;
-declare function tRecord<K extends ArkSchema, V extends ArkSchema>(key: K, value: V, opts?: Meta): ArkSchema;
-declare function tOptional<E extends ArkSchema>(schema: E, opts?: Meta): ArkSchema;
-declare function tNullable<E extends ArkSchema>(schema: E, opts?: Meta): ArkSchema;
-declare function tReadonly<E extends ArkSchema>(schema: E): ArkSchema;
-declare function tPartial<_P extends Record<string, ArkSchema>>(obj: ArkSchema): ArkSchema;
-declare function tRequired<_P extends Record<string, ArkSchema>>(obj: ArkSchema): ArkSchema;
-declare function tPick<P extends Record<string, ArkSchema>, K extends keyof P>(obj: ArkSchema, keys: readonly K[]): ArkSchema;
-declare function tOmit<P extends Record<string, ArkSchema>, K extends keyof P>(obj: ArkSchema, keys: readonly K[]): ArkSchema;
-declare function tComposite(objects: readonly ArkSchema[], opts?: Meta): ArkSchema;
-export declare const Type: {
-    readonly String: typeof tString;
-    readonly Number: typeof tNumber;
-    readonly Integer: typeof tInteger;
-    readonly Boolean: typeof tBoolean;
-    readonly Null: typeof tNull;
-    readonly Any: typeof tAny;
-    readonly Unknown: typeof tUnknown;
-    readonly Unsafe: <T = unknown>(jsonSchema?: Record<string, unknown>) => TUnsafe<T>;
-    readonly Never: typeof tNever;
-    readonly Literal: typeof tLiteral;
-    readonly Union: typeof tUnion;
-    readonly Intersect: typeof tIntersect;
-    readonly Enum: typeof tEnum;
-    readonly Array: typeof tArray;
-    readonly Tuple: typeof tTuple;
-    readonly Object: typeof tObject;
-    readonly Record: typeof tRecord;
-    readonly Optional: typeof tOptional;
-    readonly Nullable: typeof tNullable;
-    readonly Readonly: typeof tReadonly;
-    readonly Partial: typeof tPartial;
-    readonly Required: typeof tRequired;
-    readonly Pick: typeof tPick;
-    readonly Omit: typeof tOmit;
-    readonly Composite: typeof tComposite;
-};
-export type TypeBuilder = typeof Type;
-/** Default namespace export so `import * as typebox from "./typebox.js"` still resolves the `Type` key. */
-declare const _default: {
-    Type: {
-        readonly String: typeof tString;
-        readonly Number: typeof tNumber;
-        readonly Integer: typeof tInteger;
-        readonly Boolean: typeof tBoolean;
-        readonly Null: typeof tNull;
-        readonly Any: typeof tAny;
-        readonly Unknown: typeof tUnknown;
-        readonly Unsafe: <T = unknown>(jsonSchema?: Record<string, unknown>) => TUnsafe<T>;
-        readonly Never: typeof tNever;
-        readonly Literal: typeof tLiteral;
-        readonly Union: typeof tUnion;
-        readonly Intersect: typeof tIntersect;
-        readonly Enum: typeof tEnum;
-        readonly Array: typeof tArray;
-        readonly Tuple: typeof tTuple;
-        readonly Object: typeof tObject;
-        readonly Record: typeof tRecord;
-        readonly Optional: typeof tOptional;
-        readonly Nullable: typeof tNullable;
-        readonly Readonly: typeof tReadonly;
-        readonly Partial: typeof tPartial;
-        readonly Required: typeof tRequired;
-        readonly Pick: typeof tPick;
-        readonly Omit: typeof tOmit;
-        readonly Composite: typeof tComposite;
-    };
-};
-export default _default;