devframe 0.4.0 → 0.5.0

package/dist/index-DTeZXHSi.d.mts

@@ -1,639 +0,0 @@
-import { defineDiagnostics } from "nostics";
-import { BirpcReturn } from "birpc";
-import { GenericSchema, InferInput } from "valibot";
-//#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 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;
-/**
- * Serialized representation of a thrown value in a dump record.
- *
- * Errors are stored as plain objects so they round-trip through both the
- * strict-JSON and structured-clone codecs. `message` and `name` are always
- * present; `cause` and any own enumerable properties of the original
- * `Error` are preserved on a best-effort basis. Non-`Error` throws are
- * normalized to `{ name: 'Error', message: String(thrown) }`.
- */
-interface RpcDumpRecordError {
-  /** Error message (mirrors `Error.message`). */
-  message: string;
-  /** Error type name (e.g., "Error", "TypeError"). */
-  name: string;
-  /** `Error.cause`, recursively serialized when it is itself an `Error`. */
-  cause?: unknown;
-  /** Own enumerable properties of the original error (excluding `message`/`name`/`cause`). */
-  [key: string]: unknown;
-}
-/**
- * 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?: RpcDumpRecordError;
-}
-/**
- * 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>;
-/**
- * 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;
-  /**
-   * Declares whether this function's args/return are JSON-serializable
-   * (no Map/Set/Date/BigInt/cycles/class instances/undefined/Symbol/Function).
-   *
-   * - `true` — wire and dump use strict `JSON.stringify`; misshapen
-   *   values throw `DF0019` at the call site. Required for `agent`.
-   * - `false` (default) — `structured-clone-es` round-trips fancy
-   *   types. Cannot be `agent`-exposed (registration throws `DF0018`).
-   */
-  jsonSerializable?: boolean;
-  /**
-   * 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;
-  /**
-   * Declares whether this function's args/return are JSON-serializable
-   * (no Map/Set/Date/BigInt/cycles/class instances/undefined/Symbol/Function).
-   *
-   * - `true` — wire and dump use strict `JSON.stringify`; misshapen
-   *   values throw `DF0019` at the call site. Required for `agent`.
-   * - `false` (default) — `structured-clone-es` round-trips fancy
-   *   types. Cannot be `agent`-exposed (registration throws `DF0018`).
-   */
-  jsonSerializable?: boolean;
-  /**
-   * 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 RpcFunctionDefinitionAny = RpcFunctionDefinition<string, any, any, any, any, any, any>;
-type RpcFunctionDefinitionAnyWithContext<CONTEXT = undefined> = RpcFunctionDefinition<string, any, any, any, any, any, CONTEXT>;
-//#endregion
-//#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/types/events.d.ts
-interface EventsMap {
-  [event: string]: any;
-}
-interface EventUnsubscribe {
-  (): void;
-}
-interface EventEmitter<Events extends EventsMap> {
-  /**
-   * Calls each of the listeners registered for a given event.
-   *
-   * ```js
-   * ee.emit('tick', tickType, tickDuration)
-   * ```
-   *
-   * @param event The event name.
-   * @param args The arguments for listeners.
-   */
-  emit: <K extends keyof Events>(event: K, ...args: Parameters<Events[K]>) => void;
-  /**
-   * Calls the listeners for a given event once and then removes the listener.
-   *
-   * @param event The event name.
-   * @param args The arguments for listeners.
-   */
-  emitOnce: <K extends keyof Events>(event: K, ...args: Parameters<Events[K]>) => void;
-  /**
-   * Event names in keys and arrays with listeners in values.
-   *
-   * @internal
-   */
-  _listeners: Partial<{ [E in keyof Events]: Events[E][] }>;
-  /**
-   * Add a listener for a given event.
-   *
-   * ```js
-   * const unbind = ee.on('tick', (tickType, tickDuration) => {
-   *   count += 1
-   * })
-   *
-   * disable () {
-   *   unbind()
-   * }
-   * ```
-   *
-   * @param event The event name.
-   * @param cb The listener function.
-   * @returns Unbind listener from event.
-   */
-  on: <K extends keyof Events>(event: K, cb: Events[K]) => EventUnsubscribe;
-  /**
-   * Add a listener for a given event once.
-   *
-   * ```js
-   * const unbind = ee.once('tick', (tickType, tickDuration) => {
-   *   count += 1
-   * })
-   *
-   * disable () {
-   *   unbind()
-   * }
-   * ```
-   *
-   * @param event The event name.
-   * @param cb The listener function.
-   * @returns Unbind listener from event.
-   */
-  once: <K extends keyof Events>(event: K, cb: Events[K]) => EventUnsubscribe;
-}
-//#endregion
-//#region src/utils/shared-state.d.ts
-type ImmutablePrimitive = undefined | null | boolean | string | number | Function;
-type Immutable<T> = T extends ImmutablePrimitive ? T : T extends Array<infer U> ? ImmutableArray<U> : T extends Map<infer K, infer V> ? ImmutableMap<K, V> : T extends Set<infer M> ? ImmutableSet<M> : ImmutableObject<T>;
-type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
-type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
-type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
-type ImmutableObject<T> = { readonly [K in keyof T]: Immutable<T[K]> };
-/**
- * Serializable patch describing a single mutation to a `SharedState`.
- * Structurally compatible with JSON-Patch and is safe to send over RPC.
- */
-interface SharedStatePatch {
-  op: 'add' | 'remove' | 'replace';
-  path: readonly (string | number)[];
-  value?: unknown;
-}
-/**
- * State host that is immutable by default with explicit mutate.
- */
-interface SharedState<T> {
-  /**
-   * Get the current state. Immutable.
-   */
-  value: () => Immutable<T>;
-  /**
-   * Subscribe to state changes.
-   */
-  on: EventEmitter<SharedStateEvents<T>>['on'];
-  /**
-   * Mutate the state.
-   */
-  mutate: (fn: (state: T) => void, syncId?: string) => void;
-  /**
-   * Apply patches to the state.
-   */
-  patch: (patches: SharedStatePatch[], syncId?: string) => void;
-  /**
-   * Sync IDs that have been applied to the state.
-   */
-  syncIds: Set<string>;
-}
-interface SharedStateEvents<T> {
-  updated: (fullState: T, patches: SharedStatePatch[] | undefined, syncId: string) => void;
-}
-interface SharedStateOptions<T> {
-  /**
-   * Initial state.
-   */
-  initialValue: T;
-  /**
-   * Enable patches.
-   *
-   * @default false
-   */
-  enablePatches?: boolean;
-}
-declare function createSharedState<T extends object>(options: SharedStateOptions<T>): SharedState<T>;
-//#endregion
-//#region src/utils/streaming-channel.d.ts
-/**
- * Serialized error shape sent over the wire when a stream ends with a failure.
- * Stays JSON-safe so the strict-JSON encoder can carry it without coercion.
- */
-interface StreamErrorPayload {
-  name: string;
-  message: string;
-}
-/**
- * Single buffered chunk in the server-side ring buffer.
- *
- * Sequence numbers start at 1 and increment per write. Subscribers track
- * `lastSeenSeq` and ask for `afterSeq` on resubscribe so the server can
- * replay any chunks the client missed during a brief disconnect.
- */
-interface BufferedChunk<T> {
-  seq: number;
-  chunk: T;
-}
-interface StreamSinkEvents<T> {
-  /** Fired for each `write()`. The RPC layer subscribes and broadcasts. */
-  chunk: (seq: number, chunk: T) => void;
-  /** Terminal — fired exactly once per sink lifetime. */
-  end: (error?: StreamErrorPayload) => void;
-}
-interface CreateStreamSinkOptions {
-  id?: string;
-  /**
-   * Size of the per-stream ring buffer kept for replay-on-resubscribe.
-   * `0` (default) disables replay.
-   */
-  replayWindow?: number;
-}
-/**
- * Server-side producer handle. Two equivalent surfaces share one piece of
- * state: the imperative `write/error/close` triple, and a `WritableStream<T>`
- * for `pipeTo`-style consumption.
- */
-interface StreamSink<T> {
-  /** Stable id used by clients to subscribe. */
-  readonly id: string;
-  /**
-   * Aborts when the consumer cancels (server-side) or when the transport
-   * loses every subscriber. Producers should poll `signal.aborted` and exit
-   * cleanly.
-   */
-  readonly signal: AbortSignal;
-  /** `true` after `close()` / `error()`. Further writes throw. */
-  readonly closed: boolean;
-  /** Last allocated sequence number. `0` until the first write. */
-  readonly lastSeq: number;
-  write: (chunk: T) => void;
-  error: (reason: unknown) => void;
-  close: () => void;
-  /** External-cancel path. Aborts the signal so handlers can short-circuit. */
-  abort: (reason?: unknown) => void;
-  /** `WritableStream<T>` adapter — same in-memory state as the imperative API. */
-  readonly writable: WritableStream<T>;
-  /**
-   * Internal — RPC layer subscribes to receive chunk/end notifications.
-   * Not part of the public contract; do not call directly.
-   *
-   * @internal
-   */
-  readonly events: EventEmitter<StreamSinkEvents<T>>;
-  /**
-   * Internal — replay buffer. RPC layer reads on (re)subscribe to feed
-   * missed chunks before going live.
-   *
-   * @internal
-   */
-  readonly buffer: ReadonlyArray<BufferedChunk<T>>;
-}
-interface CreateStreamReaderOptions {
-  id?: string;
-  /**
-   * Maximum number of buffered chunks held client-side while the consumer
-   * isn't draining. On overflow, the oldest chunk is dropped.
-   */
-  highWaterMark?: number;
-  /**
-   * Called when the chunk queue overflows the high-water mark. The RPC
-   * layer wires this to a coded warning; the primitive itself is
-   * RPC-agnostic.
-   */
-  onOverflow?: (dropped: number) => void;
-  /** Called when the consumer cancels — the RPC layer sends `:cancel` upstream. */
-  onCancel?: () => void;
-}
-/**
- * Client-side consumer handle. Both an `AsyncIterable<T>` (for `for await`)
- * and exposes `readable: ReadableStream<T>` (for `pipeTo`). Pick one — they
- * share a single internal queue, so concurrent draining will race.
- */
-interface StreamReader<T> extends AsyncIterable<T> {
-  readonly id: string;
-  readonly cancelled: boolean;
-  readonly done: boolean;
-  /** Highest `seq` observed. Used for replay on reconnect. */
-  readonly lastSeenSeq: number;
-  /** `ReadableStream<T>` adapter for `pipeTo`-style consumption. */
-  readonly readable: ReadableStream<T>;
-  cancel: () => void;
-  /** @internal */
-  _push: (seq: number, chunk: T) => void;
-  /** @internal */
-  _end: (error?: StreamErrorPayload) => void;
-}
-/**
- * Build a server-side stream sink. RPC-agnostic — the RPC host wires
- * `events.on('chunk' | 'end')` to broadcast, and reads `buffer` to replay
- * for late or reconnecting subscribers.
- */
-declare function createStreamSink<T>(options?: CreateStreamSinkOptions): StreamSink<T>;
-/**
- * Build a client-side stream reader. RPC-agnostic — the RPC host calls
- * `_push(seq, chunk)` on each incoming chunk and `_end(error?)` on the
- * terminal frame. Consumers iterate with `for await` or pipe `readable`.
- */
-declare function createStreamReader<T>(options?: CreateStreamReaderOptions): StreamReader<T>;
-//#endregion
-//#region src/types/rpc-augments.d.ts
-/**
- * To be extended
- */
-interface DevToolsRpcClientFunctions {
-  /**
-   * Streaming chunk pushed from server to subscribed clients. Wired by
-   * `RpcStreamingHost`; do not register manually.
-   *
-   * @internal
-   */
-  'devframe:streaming:chunk': (channel: string, id: string, seq: number, chunk: any) => Promise<void>;
-  /**
-   * Streaming terminator pushed from server to subscribed clients. Wired by
-   * `RpcStreamingHost`; do not register manually.
-   *
-   * @internal
-   */
-  'devframe:streaming:end': (channel: string, id: string, error?: {
-    name: string;
-    message: string;
-  }) => Promise<void>;
-  /**
-   * Server→client cancel for an in-flight upload. Wired by
-   * `RpcStreamingHost`; do not register manually.
-   *
-   * @internal
-   */
-  'devframe:streaming:upload-cancel': (channel: string, id: string) => Promise<void>;
-}
-/**
- * To be extended
- */
-interface DevToolsRpcServerFunctions {
-  /**
-   * Subscribe a client to a shared-state key. Wired by
-   * `RpcSharedStateHost`; do not register manually.
-   *
-   * @internal
-   */
-  'devframe:rpc:server-state:subscribe': (key: string) => Promise<void>;
-  /**
-   * Read the current value for a shared-state key. Wired by
-   * `RpcSharedStateHost`; do not register manually.
-   *
-   * @internal
-   */
-  'devframe:rpc:server-state:get': (key: string) => Promise<any>;
-  /**
-   * Replace a shared-state value (from the client). Wired by
-   * `RpcSharedStateHost`; do not register manually.
-   *
-   * @internal
-   */
-  'devframe:rpc:server-state:set': (key: string, value: any, syncId: string) => Promise<void>;
-  /**
-   * Apply a patch to a shared-state value (from the client). Wired by
-   * `RpcSharedStateHost`; do not register manually.
-   *
-   * @internal
-   */
-  'devframe:rpc:server-state:patch': (key: string, patches: any[], syncId: string) => Promise<void>;
-  /**
-   * Client→server streaming subscription with optional replay cursor.
-   * Wired by `RpcStreamingHost`; do not register manually.
-   *
-   * @internal
-   */
-  'devframe:streaming:subscribe': (channel: string, id: string, opts?: {
-    afterSeq?: number;
-  }) => Promise<void>;
-  /**
-   * Client→server streaming unsubscribe. Wired by `RpcStreamingHost`;
-   * do not register manually.
-   *
-   * @internal
-   */
-  'devframe:streaming:unsubscribe': (channel: string, id: string) => Promise<void>;
-  /**
-   * Client→server streaming cancellation request. Wired by
-   * `RpcStreamingHost`; do not register manually.
-   *
-   * @internal
-   */
-  'devframe:streaming:cancel': (channel: string, id: string) => Promise<void>;
-  /**
-   * Client→server upload chunk. Wired by `RpcStreamingHost`; do not
-   * register manually.
-   *
-   * @internal
-   */
-  'devframe:streaming:upload-chunk': (channel: string, id: string, seq: number, chunk: any) => Promise<void>;
-  /**
-   * Client→server upload terminator. Wired by `RpcStreamingHost`; do not
-   * register manually.
-   *
-   * @internal
-   */
-  'devframe:streaming:upload-end': (channel: string, id: string, error?: {
-    name: string;
-    message: string;
-  }) => Promise<void>;
-}
-/**
- * To be extended
- */
-interface DevToolsRpcSharedStates {}
-//#endregion
-//#region src/types/rpc.d.ts
-interface RpcSharedStateGetOptions<T> {
-  sharedState?: SharedState<T>;
-  initialValue?: T;
-}
-interface RpcSharedStateHost {
-  get: <T extends keyof DevToolsRpcSharedStates>(key: T, options?: RpcSharedStateGetOptions<DevToolsRpcSharedStates[T]>) => Promise<SharedState<DevToolsRpcSharedStates[T]>>;
-  keys: () => string[];
-  /**
-   * Subscribe to new shared-state keys becoming available. Fires when
-   * `get(key, ...)` creates a fresh entry (not on subsequent gets).
-   * Useful for protocol adapters (e.g. MCP) that surface shared state
-   * as dynamic resources.
-   */
-  onKeyAdded: (fn: (key: string) => void) => () => void;
-}
-//#endregion
-//#region src/types/context.d.ts
-interface ConnectionMeta {
-  backend: 'websocket' | 'static';
-  websocket?: number | string;
-  /**
-   * Names of RPC functions that have declared `jsonSerializable: true`.
-   * Used by the WS / static client to dispatch the per-call wire
-   * serializer (strict JSON for these methods, structured-clone for
-   * the rest). Populated by the server / build adapter; absent on
-   * legacy clients, in which case all outgoing messages fall back to
-   * structured-clone.
-   */
-  jsonSerializableMethods?: string[];
-}
-//#endregion
-export { createSharedState as C, RpcCacheOptions as D, RpcCacheManager as E, RpcFunctionDefinitionAny as O, SharedStatePatch as S, EventsMap as T, ImmutableObject as _, BufferedChunk as a, SharedStateEvents as b, StreamErrorPayload as c, StreamSinkEvents as d, createStreamReader as f, ImmutableMap as g, ImmutableArray as h, DevToolsRpcServerFunctions as i, RpcFunctionsCollector as k, StreamReader as l, Immutable as m, RpcSharedStateHost as n, CreateStreamReaderOptions as o, createStreamSink as p, DevToolsRpcClientFunctions as r, CreateStreamSinkOptions as s, ConnectionMeta as t, StreamSink as u, ImmutableSet as v, EventEmitter as w, SharedStateOptions as x, SharedState as y };

package/dist/node/internal.mjs

@@ -1,49 +0,0 @@
-import { t as createStorage } from "../storage-CZVTPKsw.mjs";
-import { n as revokeActiveConnectionsForToken, r as revokeAuthToken, t as humanId } from "../human-id-Dq-qgtES.mjs";
-import { n as resolveBasePath, t as normalizeBasePath } from "../_shared-CUFqO4kJ.mjs";
-import { join } from "pathe";
-//#region src/node/internal/context.ts
-const internalContextMap = /* @__PURE__ */ new WeakMap();
-function getInternalContext(context) {
-	if (!internalContextMap.has(context)) {
-		const storage = createStorage({
-			filepath: join(context.host.getStorageDir("global"), "auth.json"),
-			initialValue: { trusted: {} }
-		});
-		const remoteTokens = /* @__PURE__ */ new Map();
-		function revokeRemoteToken(token) {
-			if (!remoteTokens.delete(token)) return;
-			revokeActiveConnectionsForToken(context, token);
-		}
-		const internalContext = {
-			storage: { auth: storage },
-			revokeAuthToken: (token) => revokeAuthToken(context, storage, token),
-			remoteTokens,
-			allocateRemoteToken(dockId, origin, originLock) {
-				const token = humanId();
-				remoteTokens.set(token, {
-					dockId,
-					origin,
-					originLock
-				});
-				return token;
-			},
-			revokeRemoteToken,
-			revokeRemoteTokensForDock(dockId) {
-				const tokensToRevoke = [];
-				for (const [token, record] of remoteTokens) if (record.dockId === dockId) tokensToRevoke.push(token);
-				for (const token of tokensToRevoke) revokeRemoteToken(token);
-			},
-			isRemoteTokenTrusted(token, requestOrigin) {
-				const record = remoteTokens.get(token);
-				if (!record) return false;
-				if (!record.originLock) return true;
-				return !!requestOrigin && record.origin === requestOrigin;
-			}
-		};
-		internalContextMap.set(context, internalContext);
-	}
-	return internalContextMap.get(context);
-}
-//#endregion
-export { getInternalContext, internalContextMap, normalizeBasePath, resolveBasePath };