devframe 0.0.0 → 0.1.16

package/dist/index-DvKDO5H8.d.mts

@@ -0,0 +1,333 @@
+import { GenericSchema, InferInput } from "valibot";
+import { BirpcFn, BirpcReturn as BirpcReturn$1 } from "birpc";
+
+//#region src/rpc/cache.d.ts
+interface RpcCacheOptions {
+  functions: string[];
+  keySerializer?: (args: unknown[]) => string;
+}
+/**
+ * @experimental API is expected to change.
+ */
+declare class RpcCacheManager {
+  private cacheMap;
+  private options;
+  private keySerializer;
+  constructor(options: RpcCacheOptions);
+  updateOptions(options: Partial<RpcCacheOptions>): void;
+  cached<T>(m: string, a: unknown[]): T | undefined;
+  apply(req: {
+    m: string;
+    a: unknown[];
+  }, res: unknown): void;
+  validate(m: string): boolean;
+  clear(fn?: string): void;
+}
+//#endregion
+//#region src/rpc/utils.d.ts
+/** Infers TypeScript tuple type from Valibot schema array */
+type InferArgsType<S extends RpcArgsSchema | undefined> = S extends readonly [] ? [] : S extends readonly [infer H, ...infer T] ? H extends GenericSchema ? T extends readonly GenericSchema[] ? [InferInput<H>, ...InferArgsType<T>] : never : never : never;
+/** Infers TypeScript return type from Valibot return schema */
+type InferReturnType<S extends RpcReturnSchema | undefined> = S extends RpcReturnSchema ? InferInput<S> : void;
+//#endregion
+//#region src/rpc/types.d.ts
+type Thenable<T> = T | Promise<T>;
+type EntriesToObject<T extends readonly [string, any][]> = { [K in T[number] as K[0]]: K[1] };
+/**
+ * Type of the RPC function,
+ * - static: A function that returns a static data, no arguments (can be cached and dumped)
+ * - action: A function that performs an action (no data returned)
+ * - event: A function that emits an event (no data returned), and does not wait for a response
+ * - query: A function that queries a resource
+ *
+ * By default, the function is a query function.
+ */
+type RpcFunctionType = 'static' | 'action' | 'event' | 'query';
+/**
+ * Agent exposure settings for an RPC function. When this field is set,
+ * the function is surfaced to agents (e.g. via the devframe MCP adapter)
+ * as a callable tool. Functions without an `agent` field are not exposed —
+ * default-deny.
+ *
+ * @experimental The agent-native surface is experimental and may change
+ * without a major version bump until it stabilizes.
+ */
+interface RpcFunctionAgentOptions {
+  /**
+   * Human-readable description shown to the agent. Required — agents
+   * rely on this to decide when to invoke the tool. Keep it to ~1–3
+   * sentences explaining what the tool does and when to use it.
+   */
+  description: string;
+  /**
+   * Optional human-friendly display title. Maps to the MCP tool `title`
+   * annotation. Falls back to the RPC function `name` when omitted.
+   */
+  title?: string;
+  /**
+   * Safety classification. Drives MCP annotations (`readOnlyHint`,
+   * `destructiveHint`) downstream.
+   * - `'read'` — no side effects; safe to call freely.
+   * - `'action'` — mutates state but not destructive.
+   * - `'destructive'` — may perform destructive updates.
+   *
+   * When omitted it is inferred from the function `type`:
+   *   - `'static'` / `'query'` → `'read'`
+   *   - `'action'` / `'event'` → `'action'`
+   */
+  safety?: 'read' | 'action' | 'destructive';
+  /** Free-form tags for grouping or filtering. */
+  tags?: readonly string[];
+  /**
+   * Optional example invocations shown to agents. Returned verbatim in
+   * the agent manifest.
+   */
+  examples?: readonly {
+    args: unknown[];
+    description?: string;
+  }[];
+}
+/**
+ * Manages dynamic function registration and provides a type-safe proxy for accessing functions.
+ */
+interface RpcFunctionsCollector<LocalFunctions, SetupContext = undefined> {
+  /** User-provided context passed to setup functions */
+  context: SetupContext;
+  /** Type-safe proxy for calling registered functions */
+  readonly functions: LocalFunctions;
+  /** Map of registered function definitions keyed by function name */
+  readonly definitions: Map<string, RpcFunctionDefinitionAnyWithContext<SetupContext>>;
+  /** Register a new function definition */
+  register: (fn: RpcFunctionDefinitionAnyWithContext<SetupContext>) => void;
+  /** Update an existing function definition */
+  update: (fn: RpcFunctionDefinitionAnyWithContext<SetupContext>) => void;
+  /** Subscribe to function changes, returns unsubscribe function */
+  onChanged: (fn: (id?: string) => void) => (() => void);
+}
+/**
+ * Result returned by a function's setup method.
+ */
+interface RpcFunctionSetupResult<ARGS extends any[], RETURN = void> {
+  /** Function handler */
+  handler?: (...args: ARGS) => RETURN;
+  /** Optional dump definition (overrides definition-level dump) */
+  dump?: RpcDumpDefinition<ARGS, RETURN>;
+}
+/** Valibot schema array for validating function arguments */
+type RpcArgsSchema = readonly GenericSchema[];
+/** Valibot schema for validating function return value */
+type RpcReturnSchema = GenericSchema;
+/**
+ * Single record in a dump store with pre-computed results.
+ */
+interface RpcDumpRecord<ARGS extends any[] = any[], RETURN = any> {
+  /** Function arguments */
+  inputs: ARGS;
+  /** Result (value or lazy function) */
+  output?: RETURN;
+  /** Error if execution failed */
+  error?: {
+    /** Error message */message: string; /** Error type name (e.g., "Error", "TypeError") */
+    name: string;
+  };
+}
+/**
+ * Defines argument combinations to pre-compute for a function.
+ */
+interface RpcDumpDefinition<ARGS extends any[] = any[], RETURN = any> {
+  /** Argument combinations to pre-compute by executing handler */
+  inputs?: ARGS[];
+  /** Pre-computed records to use directly (bypasses handler execution) */
+  records?: RpcDumpRecord<ARGS, RETURN>[];
+  /** Fallback value when no match found */
+  fallback?: RETURN;
+}
+/**
+ * Dynamically generates dump definitions based on context.
+ */
+type RpcDumpGetter<ARGS extends any[] = any[], RETURN = any, CONTEXT = any> = (context: CONTEXT, handler: (...args: ARGS) => RETURN) => Thenable<RpcDumpDefinition<ARGS, RETURN>>;
+/**
+ * Dump configuration (static object or dynamic function).
+ */
+type RpcDump<ARGS extends any[] = any[], RETURN = any, CONTEXT = any> = RpcDumpDefinition<ARGS, RETURN> | RpcDumpGetter<ARGS, RETURN, CONTEXT>;
+/**
+ * Base function definition metadata.
+ */
+interface RpcFunctionDefinitionBase {
+  /** Function name (unique identifier) */
+  name: string;
+  /** Function type (static, action, event, or query) */
+  type?: RpcFunctionType;
+}
+/**
+ * Dump store containing pre-computed results.
+ * Flat structure for serialization and efficient lookups.
+ */
+interface RpcDumpStore<T = any> {
+  /** Function definitions keyed by name */
+  definitions: Record<string, RpcFunctionDefinitionBase>;
+  /** Records keyed by '<function-name>---<hash>' or '<function-name>---fallback' */
+  records: Record<string, RpcDumpRecord | (() => Promise<RpcDumpRecord>)>;
+  /** @internal */
+  _functions?: T;
+}
+/**
+ * Dump client options.
+ */
+interface RpcDumpClientOptions {
+  /** Called when arguments don't match any pre-computed entry */
+  onMiss?: (functionName: string, args: any[]) => void;
+}
+/**
+ * Options for collecting dumps.
+ */
+interface RpcDumpCollectionOptions {
+  /**
+   * Concurrency control for parallel execution.
+   * - `false` or `undefined`: sequential execution (default)
+   * - `true`: parallel execution with concurrency limit of 5
+   * - `number`: parallel execution with specified concurrency limit
+   */
+  concurrency?: boolean | number | null;
+}
+/**
+ * RPC function definition with optional dump support.
+ */
+type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = 'query', ARGS extends any[] = [], RETURN = void, AS extends RpcArgsSchema | undefined = undefined, RS extends RpcReturnSchema | undefined = undefined, CONTEXT = undefined> = [AS, RS] extends [undefined, undefined] ? {
+  /** Function name (unique identifier) */name: NAME; /** Function type (static, action, event, or query) */
+  type?: TYPE; /** Whether the function results should be cached */
+  cacheable?: boolean; /** Valibot schema array for validating function arguments */
+  args?: AS; /** Valibot schema for validating function return value */
+  returns?: RS;
+  /**
+   * Expose this function to agents (e.g. via the MCP adapter).
+   * When omitted, the function is not agent-exposed (default-deny).
+   *
+   * @experimental
+   */
+  agent?: RpcFunctionAgentOptions; /** Setup function called with context to initialize handler and dump */
+  setup?: (context: CONTEXT) => Thenable<RpcFunctionSetupResult<ARGS, RETURN>>; /** Function implementation (required if setup doesn't provide one) */
+  handler?: (...args: ARGS) => RETURN; /** Dump definition (setup dump takes priority) */
+  dump?: RpcDump<ARGS, RETURN, CONTEXT>;
+  /**
+   * Sugar for "query in dev, single baked snapshot in build": when
+   * `true` and no `dump` is provided, the build adapter runs the
+   * handler once with no arguments and stores the result as both a
+   * no-args record and the fallback so any call variant resolves
+   * to the same snapshot. Only valid on `query` (or untyped)
+   * functions — `static` already has equivalent default behavior.
+   */
+  snapshot?: boolean;
+  __resolved?: RpcFunctionSetupResult<ARGS, RETURN>;
+  __promise?: Thenable<RpcFunctionSetupResult<ARGS, RETURN>>;
+} : {
+  /** Function name (unique identifier) */name: NAME; /** Function type (static, action, event, or query) */
+  type?: TYPE; /** Whether the function results should be cached */
+  cacheable?: boolean; /** Valibot schema array for validating function arguments */
+  args: AS; /** Valibot schema for validating function return value */
+  returns: RS;
+  /**
+   * Expose this function to agents (e.g. via the MCP adapter).
+   * When omitted, the function is not agent-exposed (default-deny).
+   *
+   * @experimental
+   */
+  agent?: RpcFunctionAgentOptions; /** Setup function called with context to initialize handler and dump */
+  setup?: (context: CONTEXT) => Thenable<RpcFunctionSetupResult<InferArgsType<AS>, InferReturnType<RS>>>; /** Function implementation (required if setup doesn't provide one) */
+  handler?: (...args: InferArgsType<AS>) => InferReturnType<RS>; /** Dump definition (setup dump takes priority) */
+  dump?: RpcDump<InferArgsType<AS>, InferReturnType<RS>, CONTEXT>;
+  /**
+   * Sugar for "query in dev, single baked snapshot in build": when
+   * `true` and no `dump` is provided, the build adapter runs the
+   * handler once with no arguments and stores the result as both a
+   * no-args record and the fallback so any call variant resolves
+   * to the same snapshot. Only valid on `query` (or untyped)
+   * functions — `static` already has equivalent default behavior.
+   */
+  snapshot?: boolean;
+  __resolved?: RpcFunctionSetupResult<InferArgsType<AS>, InferReturnType<RS>>;
+  __promise?: Thenable<RpcFunctionSetupResult<InferArgsType<AS>, InferReturnType<RS>>>;
+};
+type RpcFunctionDefinitionToFunction<T extends RpcFunctionDefinitionAny> = T extends {
+  args: infer AS;
+  returns: infer RS;
+} ? AS extends RpcArgsSchema ? RS extends RpcReturnSchema ? (...args: InferArgsType<AS>) => InferReturnType<RS> : never : never : T extends RpcFunctionDefinition<string, any, infer ARGS, infer RETURN, any, any, any> ? (...args: ARGS) => RETURN : never;
+type RpcFunctionDefinitionAny = RpcFunctionDefinition<string, any, any, any, any, any, any>;
+type RpcFunctionDefinitionAnyWithContext<CONTEXT = undefined> = RpcFunctionDefinition<string, any, any, any, any, any, CONTEXT>;
+type RpcDefinitionsToFunctions<T extends readonly RpcFunctionDefinitionAny[]> = EntriesToObject<{ [K in keyof T]: [T[K]['name'], RpcFunctionDefinitionToFunction<T[K]>] }>;
+type RpcDefinitionsFilter<T extends readonly RpcFunctionDefinitionAny[], Type extends RpcFunctionType> = { [K in keyof T]: T[K] extends {
+  type: Type;
+} ? T[K] : never };
+//#endregion
+//#region src/rpc/collector.d.ts
+declare class RpcFunctionsCollectorBase<LocalFunctions extends Record<string, any>, SetupContext> implements RpcFunctionsCollector<LocalFunctions, SetupContext> {
+  readonly context: SetupContext;
+  readonly definitions: Map<string, RpcFunctionDefinition<string, any, any, any, any, any, SetupContext>>;
+  readonly functions: LocalFunctions;
+  private readonly _onChanged;
+  constructor(context: SetupContext);
+  register(fn: RpcFunctionDefinition<string, any, any, any, any, any, SetupContext>, force?: boolean): void;
+  update(fn: RpcFunctionDefinition<string, any, any, any, any, any, SetupContext>, force?: boolean): void;
+  onChanged(fn: (id?: string) => void): () => void;
+  getHandler<T extends keyof LocalFunctions>(name: T): Promise<LocalFunctions[T]>;
+  getSchema<T extends keyof LocalFunctions>(name: T): {
+    args: RpcArgsSchema | undefined;
+    returns: RpcReturnSchema | undefined;
+  };
+  has(name: string): boolean;
+  get(name: string): RpcFunctionDefinition<string, any, any, any, any, any, SetupContext> | undefined;
+  list(): string[];
+}
+//#endregion
+//#region src/rpc/define.d.ts
+declare function defineRpcFunction<NAME extends string, TYPE extends RpcFunctionType, ARGS extends any[], RETURN = void, const AS extends RpcArgsSchema | undefined = undefined, const RS extends RpcReturnSchema | undefined = undefined>(definition: RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS>): RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS>;
+declare function createDefineWrapperWithContext<CONTEXT>(): <NAME extends string, TYPE extends RpcFunctionType, ARGS extends any[], RETURN = void, const AS extends RpcArgsSchema | undefined = undefined, const RS extends RpcReturnSchema | undefined = undefined>(definition: RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, CONTEXT>) => RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, CONTEXT>;
+//#endregion
+//#region src/rpc/dumps.d.ts
+/**
+ * Collects pre-computed dumps by executing functions with their defined input combinations.
+ * Static functions without dump config automatically get `{ inputs: [[]] }`.
+ *
+ * @example
+ * ```ts
+ * const store = await dumpFunctions([greet], context, { concurrency: 10 })
+ * ```
+ */
+declare function dumpFunctions<T extends readonly RpcFunctionDefinitionAny[]>(definitions: T, context?: any, options?: RpcDumpCollectionOptions): Promise<RpcDumpStore<RpcDefinitionsToFunctions<T>>>;
+/**
+ * Creates a client that serves pre-computed results from a dump store.
+ * Uses argument hashing to match calls to stored records.
+ *
+ * @example
+ * ```ts
+ * const client = createClientFromDump(store)
+ * await client.greet('Alice')
+ * ```
+ */
+declare function createClientFromDump<T extends Record<string, any>>(store: RpcDumpStore<T>, options?: RpcDumpClientOptions): BirpcReturn$1<T>;
+/**
+ * Filters function definitions to only those with dump definitions.
+ * Note: Only checks the definition itself, not setup results.
+ */
+declare function getDefinitionsWithDumps<T extends readonly RpcFunctionDefinitionAny[]>(definitions: T): RpcFunctionDefinitionAny[];
+//#endregion
+//#region src/rpc/handler.d.ts
+declare function getRpcResolvedSetupResult<NAME extends string, TYPE extends RpcFunctionType, ARGS extends any[], RETURN = void, CONTEXT = undefined>(definition: RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, any, any, CONTEXT>, context: CONTEXT): Promise<RpcFunctionSetupResult<ARGS, RETURN>>;
+declare function getRpcHandler<NAME extends string, TYPE extends RpcFunctionType, ARGS extends any[], RETURN = void, CONTEXT = undefined>(definition: RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, any, any, CONTEXT>, context: CONTEXT): Promise<(...args: ARGS) => RETURN>;
+//#endregion
+//#region src/rpc/validation.d.ts
+/**
+ * Validates RPC function definitions.
+ * Action and event functions cannot have dumps (side effects should not be cached).
+ *
+ * @throws {Error} If an action or event function has a dump configuration
+ */
+declare function validateDefinitions(definitions: readonly RpcFunctionDefinitionAny[]): void;
+/**
+ * Validates a single RPC function definition.
+ *
+ * @throws {Error} If an action or event function has a dump configuration
+ */
+declare function validateDefinition(definition: RpcFunctionDefinitionAny): void;
+//#endregion
+export { RpcFunctionSetupResult as A, RpcDumpStore as C, RpcFunctionDefinitionAnyWithContext as D, RpcFunctionDefinitionAny as E, RpcCacheManager as F, RpcCacheOptions as I, RpcFunctionsCollector as M, RpcReturnSchema as N, RpcFunctionDefinitionBase as O, Thenable as P, RpcDumpRecord as S, RpcFunctionDefinition as T, RpcDump as _, createClientFromDump as a, RpcDumpDefinition as b, createDefineWrapperWithContext as c, BirpcFn as d, BirpcReturn$1 as f, RpcDefinitionsToFunctions as g, RpcDefinitionsFilter as h, getRpcResolvedSetupResult as i, RpcFunctionType as j, RpcFunctionDefinitionToFunction as k, defineRpcFunction as l, RpcArgsSchema as m, validateDefinitions as n, dumpFunctions as o, EntriesToObject as p, getRpcHandler as r, getDefinitionsWithDumps as s, validateDefinition as t, RpcFunctionsCollectorBase as u, RpcDumpClientOptions as v, RpcFunctionAgentOptions as w, RpcDumpGetter as x, RpcDumpCollectionOptions as y };

package/dist/index.d.mts

@@ -0,0 +1,10 @@
+import { $ as DevToolsLogsHost, A as DevToolsViewHost, At as AgentHandle, B as DevToolsTerminalStatus, Bt as EventUnsubscribe, Ct as DevToolsCommandHandle, Dt as DevToolsCommandsHostEvents, Et as DevToolsCommandsHost, F as DevToolsChildProcessTerminalSession, Ft as AgentTool, G as DevToolsLogElementPosition, H as DevToolsRpcClientFunctions, Ht as CliFlagsSchema, I as DevToolsTerminalHost, It as AgentToolInput, J as DevToolsLogEntryInput, K as DevToolsLogEntry, L as DevToolsTerminalSession, Lt as DevToolsAgentHost, M as PartialWithoutId, Mt as AgentResource, N as Thenable, Nt as AgentResourceContent, Ot as DevToolsServerCommandEntry, P as DevToolsChildProcessExecuteOptions, Pt as AgentResourceInput, Q as DevToolsLogsClient, R as DevToolsTerminalSessionBase, Rt as DevToolsAgentHostEvents, St as DevToolsCommandEntry, Tt as DevToolsCommandShortcutOverrides, U as DevToolsRpcServerFunctions, Ut as InferCliFlags, V as DevToolsDocksUserSettings, Vt as EventsMap, W as DevToolsRpcSharedStates, Wt as defineCliFlags, X as DevToolsLogHandle, Y as DevToolsLogFilePosition, Z as DevToolsLogLevel, _ as RpcSharedStateGetOptions, _t as JsonRenderSpec, a as DevtoolRuntime, at as DevToolsDockEntryCategory, bt as DevToolsClientCommand, c as defineDevtool, ct as DevToolsDockUserEntry, d as DevToolsNodeContext, dt as DevToolsViewCustomRender, et as DevToolsHost, f as DevToolsNodeUtils, ft as DevToolsViewIframe, g as RpcFunctionsHost, gt as JsonRenderElement, h as RpcBroadcastOptions, ht as DevToolsViewLauncherStatus, i as DevtoolDeploymentKind, it as DevToolsDockEntryBase, j as EntriesToObject, jt as AgentManifest, kt as DevToolsServerCommandInput, l as ConnectionMeta, lt as DevToolsViewAction, m as DevToolsNodeRpcSession, mt as DevToolsViewLauncher, n as DevtoolCliOptions, nt as DevToolsDockEntriesGrouped, o as DevtoolSetupInfo, ot as DevToolsDockEntryIcon, p as RemoteConnectionInfo, pt as DevToolsViewJsonRender, q as DevToolsLogEntryFrom, r as DevtoolDefinition, rt as DevToolsDockEntry, s as DevtoolSpaOptions, st as DevToolsDockHost, t as DevtoolBrowserContext, tt as ClientScriptEntry, u as DevToolsCapabilities, ut as DevToolsViewBuiltin, v as RpcSharedStateHost, vt as JsonRenderer, wt as DevToolsCommandKeybinding, xt as DevToolsCommandBase, yt as RemoteDockOptions, z as DevToolsTerminalSessionStreamChunkEvent, zt as EventEmitter } from "./devtool-OJ3QW0ns.mjs";
+import { N as RpcReturnSchema, T as RpcFunctionDefinition, j as RpcFunctionType, m as RpcArgsSchema, w as RpcFunctionAgentOptions } from "./index-DvKDO5H8.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "./ws-server--IuUAaGi.mjs";
+
+//#region src/define.d.ts
+declare const defineRpcFunction: <NAME extends string, TYPE extends RpcFunctionType, ARGS extends any[], RETURN = void, const AS extends RpcArgsSchema | undefined = undefined, const RS extends RpcReturnSchema | undefined = undefined>(definition: RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, DevToolsNodeContext>) => RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, DevToolsNodeContext>;
+declare function defineCommand(command: DevToolsServerCommandInput): DevToolsServerCommandInput;
+declare function defineJsonRenderSpec(spec: JsonRenderSpec): JsonRenderSpec;
+//#endregion
+export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, type CliFlagsSchema, ClientScriptEntry, ConnectionMeta, DevToolsAgentHost, DevToolsAgentHostEvents, DevToolsCapabilities, DevToolsChildProcessExecuteOptions, DevToolsChildProcessTerminalSession, DevToolsClientCommand, DevToolsCommandBase, DevToolsCommandEntry, DevToolsCommandHandle, DevToolsCommandKeybinding, DevToolsCommandShortcutOverrides, DevToolsCommandsHost, DevToolsCommandsHostEvents, DevToolsDockEntriesGrouped, DevToolsDockEntry, DevToolsDockEntryBase, DevToolsDockEntryCategory, DevToolsDockEntryIcon, DevToolsDockHost, DevToolsDockUserEntry, DevToolsDocksUserSettings, DevToolsHost, DevToolsLogElementPosition, DevToolsLogEntry, DevToolsLogEntryFrom, DevToolsLogEntryInput, DevToolsLogFilePosition, DevToolsLogHandle, DevToolsLogLevel, DevToolsLogsClient, DevToolsLogsHost, DevToolsNodeContext, DevToolsNodeRpcSession, DevToolsNodeRpcSessionMeta, DevToolsNodeUtils, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevToolsRpcSharedStates, DevToolsServerCommandEntry, DevToolsServerCommandInput, DevToolsTerminalHost, DevToolsTerminalSession, DevToolsTerminalSessionBase, DevToolsTerminalSessionStreamChunkEvent, DevToolsTerminalStatus, DevToolsViewAction, DevToolsViewBuiltin, DevToolsViewCustomRender, DevToolsViewHost, DevToolsViewIframe, DevToolsViewJsonRender, DevToolsViewLauncher, DevToolsViewLauncherStatus, DevtoolBrowserContext, DevtoolCliOptions, DevtoolDefinition, DevtoolDeploymentKind, DevtoolRuntime, DevtoolSetupInfo, DevtoolSpaOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, type InferCliFlags, JsonRenderElement, JsonRenderSpec, JsonRenderer, PartialWithoutId, RemoteConnectionInfo, RemoteDockOptions, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, Thenable, defineCliFlags, defineCommand, defineDevtool, defineJsonRenderSpec, defineRpcFunction };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { i as defineCliFlags, n as defineJsonRenderSpec, r as defineRpcFunction, t as defineCommand } from "./src-BoIqXRc9.mjs";
+export { defineCliFlags, defineCommand, defineJsonRenderSpec, defineRpcFunction };