devframe 0.9.20 → 0.10.0

package/dist/{host-agent-C3MBpNCd.mjs → host-agent-ZSKgzMVu.mjs}

@@ -1,5 +1,5 @@
 import { t as DEVFRAME_EVENTS } from "./events-BV4Dj59a.mjs";
-import { t as diagnostics } from "./diagnostics-DZA6KQ_Z.mjs";
+import { t as diagnostics } from "./diagnostics-Cx4_VjlG.mjs";
 //#region src/utils/events.ts
 /**
 * Create event emitter.
@@ -67,11 +67,6 @@ function toolInputToRpcArgs(input, argumentCount) {
 function toolInputToCommandArgs(input, argumentCount) {
 	return collectPositionalArgs(input, argumentCount) ?? [];
 }
-/** @deprecated Use {@link toolInputToRpcArgs} or {@link toolInputToCommandArgs}. */
-function coerceAgentPositionalArgs(input, schemas, fallback = "wrap") {
-	const argumentCount = schemas?.length;
-	return fallback === "drop" ? toolInputToCommandArgs(input, argumentCount) : toolInputToRpcArgs(input, argumentCount);
-}
 //#endregion
 //#region src/node/host-agent.ts
 /**
@@ -273,4 +268,4 @@ function inferSafety(type) {
 	return "action";
 }
 //#endregion
-export { createEventEmitter as i, coerceAgentPositionalArgs as n, toolInputToCommandArgs as r, DevframeAgentHost as t };
+export { toolInputToCommandArgs as n, createEventEmitter as r, DevframeAgentHost as t };

package/dist/import-runtime-module-BzlEQ9PI.mjs

@@ -0,0 +1,24 @@
+import { i as resolveServicePackage, r as importServicePackage } from "./services-install-D5YUwFXW.mjs";
+//#region src/node/import-runtime-module.ts
+/**
+* Resolve and import a package at runtime without adding it to a consumer's
+* bundle graph. First-party adapters use this for modules whose code is
+* needed only when the matching feature is enabled (optional peers, and the
+* MCP adapter with the SDK behind it).
+*
+* @internal
+*/
+async function importRuntimeModule(specifier) {
+	return await importServicePackage(specifier, [import.meta.url]);
+}
+/**
+* Whether {@link importRuntimeModule} would resolve `specifier`, without
+* importing anything. The zero-cost probe behind optional-peer decisions.
+*
+* @internal
+*/
+function isRuntimeModuleResolvable(specifier) {
+	return resolveServicePackage(specifier, [import.meta.url]) !== void 0;
+}
+//#endregion
+export { isRuntimeModuleResolvable as n, importRuntimeModule as t };

package/dist/in-page-channel/index.d.mts

@@ -1,6 +1,5 @@
-import { A as InferReturnType, D as RpcReturnSchema, O as Thenable, i as RpcArgsSchema, k as InferArgsType } from "../types-D2vGd7-2.mjs";
-import { Vt as EventEmitter, k as SharedState } from "../context-BLHBDQcZ.mjs";
-import { BirpcReturn } from "birpc";
+import { D as InferArgsType, E as Thenable, O as InferReturnType, T as RpcReturnSchema, n as RpcArgsSchema } from "../types-BmDbfHCx.mjs";
+import { Kt as EventEmitter, k as SharedState } from "../context-CTAxz9ec.mjs";
 //#region src/in-page-channel/types.d.ts
 /**
  * The shared contract of one in-page channel, declared once (usually in a
@@ -269,8 +268,6 @@ interface PageScriptChannel<P extends InPageChannelProtocol> {
   readonly events: Pick<EventEmitter<PageScriptChannelEvents<P>>, 'on' | 'once'>;
   /** Fan an event out to every connected panel. */
   emit: <K extends keyof PanelEvents<P> & string>(name: K, ...args: FnArgs<PanelEvents<P>[K]>) => void;
-  /** @deprecated Use `emit()` instead. */
-  callEvent: <K extends keyof PanelEvents<P> & string>(name: K, ...args: FnArgs<PanelEvents<P>[K]>) => void;
   /** Subscribe to an event emitted by a panel. Returns an unsubscribe function. */
   on: <K extends keyof PageScriptEvents<P> & string>(name: K, listener: (...args: FnArgs<PageScriptEvents<P>[K]>) => void) => () => void;
   /** Page-script-authoritative shared states, replayed to joining panels. */
@@ -314,8 +311,6 @@ interface PanelChannel<P extends InPageChannelProtocol> {
    * (up to `eventBufferLimit`) and flushed on connect.
    */
   emit: <K extends keyof PageScriptEvents<P> & string>(name: K, ...args: FnArgs<PageScriptEvents<P>[K]>) => void;
-  /** @deprecated Use `emit()` instead. */
-  callEvent: <K extends keyof PageScriptEvents<P> & string>(name: K, ...args: FnArgs<PageScriptEvents<P>[K]>) => void;
   /** Subscribe to an event emitted by the page script. Returns an unsubscribe function. */
   on: <K extends keyof PanelEvents<P> & string>(name: K, listener: (...args: FnArgs<PanelEvents<P>[K]>) => void) => () => void;
   /** Shared states mirrored from the page-script authority. */

package/dist/in-page-channel/index.mjs

@@ -1,8 +1,7 @@
-import { n as DEVFRAME_EVENTS, t as defineDiagnostics } from "../nostics-DD6gsDZA.mjs";
+import { n as defineDiagnostics, r as DEVFRAME_EVENTS, t as createBirpc } from "../dist-Bw3EbMj4.mjs";
 import { createEventEmitter } from "../utils/events.mjs";
 import { t as createSharedState } from "../shared-state-eQVYHNqA.mjs";
 import { nanoid } from "../utils/nanoid.mjs";
-import { createBirpc } from "birpc";
 //#region src/in-page-channel/diagnostics.ts
 const diagnostics = /* #__PURE__ */ defineDiagnostics({
 	docsBase: "https://devfra.me/errors",
@@ -632,7 +631,6 @@ function createPageScriptChannel(options) {
 			once: events.once
 		},
 		emit,
-		callEvent: emit,
 		on: (fnName, listener) => registry.on(fnName, listener),
 		sharedState: stateHost,
 		addPanelPort: (port) => addPeer(port, `transport:${nanoid(8)}`),
@@ -867,7 +865,6 @@ function connectPanelChannel(options) {
 		},
 		call: (fnName, ...args) => enqueueCall(channelMethod("function", fnName), serializeArgs(codec, args)),
 		emit: (fnName, ...args) => sendEvent(channelMethod("event", fnName), serializeArgs(codec, args)),
-		callEvent: (fnName, ...args) => sendEvent(channelMethod("event", fnName), serializeArgs(codec, args)),
 		on: (fnName, listener) => registry.on(fnName, listener),
 		sharedState: stateHost,
 		close: () => {

package/dist/index-Bia1vKjL.d.mts

@@ -0,0 +1,218 @@
+//#region ../../node_modules/.pnpm/birpc@4.2.0/node_modules/birpc/dist/index.d.mts
+//#region src/messages.d.ts
+declare const TYPE_REQUEST: "q";
+interface RpcRequest {
+  /**
+   * Type
+   */
+  t: typeof TYPE_REQUEST;
+  /**
+   * ID
+   */
+  i?: string;
+  /**
+   * Method
+   */
+  m: string;
+  /**
+   * Arguments
+   */
+  a: any[];
+  /**
+   * Optional
+   */
+  o?: boolean;
+}
+//#endregion
+//#region src/utils.d.ts
+type ArgumentsType<T> = T extends ((...args: infer A) => any) ? A : never;
+type ReturnType<T> = T extends ((...args: any) => infer R) ? R : never;
+type Thenable<T> = T | PromiseLike<T>;
+//#endregion
+//#region src/main.d.ts
+type PromisifyFn<T> = ReturnType<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
+type BirpcResolver<This> = (this: This, name: string, resolved: (...args: unknown[]) => unknown) => Thenable<((...args: any[]) => any) | undefined>;
+interface ChannelOptions {
+  /**
+   * Function to post raw message
+   */
+  post: (data: any, ...extras: any[]) => Thenable<any>;
+  /**
+   * Listener to receive raw message
+   */
+  on: (fn: (data: any, ...extras: any[]) => void) => Thenable<any>;
+  /**
+   * Clear the listener when `$close` is called
+   */
+  off?: (fn: (data: any, ...extras: any[]) => void) => Thenable<any>;
+  /**
+   * Custom function to serialize data
+   *
+   * by default it passes the data as-is
+   */
+  serialize?: (data: any) => any;
+  /**
+   * Custom function to deserialize data
+   *
+   * by default it passes the data as-is
+   */
+  deserialize?: (data: any) => any;
+  /**
+   * Call the methods with the RPC context or the original functions object
+   */
+  bind?: 'rpc' | 'functions';
+  /**
+   * Custom meta data to attached to the RPC instance's `$meta` property
+   */
+  meta?: any;
+}
+interface EventOptions<RemoteFunctions extends object = Record<string, unknown>, LocalFunctions extends object = Record<string, unknown>, Proxify extends boolean = true> {
+  /**
+   * Names of remote functions that do not need response.
+   */
+  eventNames?: (keyof RemoteFunctions)[];
+  /**
+   * Maximum timeout for waiting for response, in milliseconds.
+   *
+   * @default 60_000
+   */
+  timeout?: number;
+  /**
+   * Whether to proxy the remote functions.
+   *
+   * When `proxify` is false, calling the remote function
+   * with `rpc.$call('method', ...args)` instead of `rpc.method(...args)`
+   * explicitly is required.
+   *
+   * @default true
+   */
+  proxify?: Proxify;
+  /**
+   * Custom resolver to resolve function to be called
+   *
+   * For advanced use cases only
+   */
+  resolver?: BirpcResolver<BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>>;
+  /**
+   * Hook triggered before an event is sent to the remote
+   *
+   * @param req - Request parameters
+   * @param next - Function to continue the request
+   * @param resolve - Function to resolve the response directly
+   */
+  onRequest?: (this: BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>, req: RpcRequest, next: (req?: RpcRequest) => Promise<any>, resolve: (res: any) => void) => void | Promise<void>;
+  /**
+   * Custom error handler for errors occurred in local functions being called
+   *
+   * @returns `true` to prevent the error from being thrown
+   */
+  onFunctionError?: (this: BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>, error: Error, functionName: string, args: any[]) => boolean | void;
+  /**
+   * Custom error handler for errors occurred during serialization or messsaging
+   *
+   * @returns `true` to prevent the error from being thrown
+   */
+  onGeneralError?: (this: BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>, error: Error, functionName?: string, args?: any[]) => boolean | void;
+  /**
+   * Custom error handler for timeouts
+   *
+   * @returns `true` to prevent the error from being thrown
+   */
+  onTimeoutError?: (this: BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>, functionName: string, args: any[]) => boolean | void;
+}
+type BirpcOptions<RemoteFunctions extends object = Record<string, unknown>, LocalFunctions extends object = Record<string, unknown>, Proxify extends boolean = true> = EventOptions<RemoteFunctions, LocalFunctions, Proxify> & ChannelOptions;
+type BirpcFn<T> = PromisifyFn<T> & {
+  /**
+   * Send event without asking for response
+   */
+  asEvent: (...args: ArgumentsType<T>) => Promise<void>;
+};
+interface BirpcReturnBuiltin<RemoteFunctions, LocalFunctions = Record<string, unknown>> {
+  /**
+   * Raw functions object
+   */
+  $functions: LocalFunctions;
+  /**
+   * Whether the RPC is closed
+   */
+  readonly $closed: boolean;
+  /**
+   * Custom meta data attached to the RPC instance
+   */
+  readonly $meta: any;
+  /**
+   * Close the RPC connection
+   */
+  $close: (error?: Error) => void;
+  /**
+   * Reject pending calls
+   */
+  $rejectPendingCalls: (handler?: PendingCallHandler) => Promise<void>[];
+  /**
+   * Call the remote function and wait for the result.
+   * An alternative to directly calling the function
+   */
+  $call: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<Awaited<ReturnType<RemoteFunctions[K]>>>;
+  /**
+   * Same as `$call`, but returns `undefined` if the function is not defined on the remote side.
+   */
+  $callOptional: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<Awaited<ReturnType<RemoteFunctions[K]> | undefined>>;
+  /**
+   * Send event without asking for response
+   */
+  $callEvent: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<void>;
+  /**
+   * Call the remote function with the raw options.
+   */
+  $callRaw: (options: {
+    method: string;
+    args: unknown[];
+    event?: boolean;
+    optional?: boolean;
+  }) => Promise<Awaited<ReturnType<any>>[]>;
+}
+type ProxifiedRemoteFunctions<RemoteFunctions extends object = Record<string, unknown>> = { [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>; };
+type BirpcReturn<RemoteFunctions extends object = Record<string, unknown>, LocalFunctions extends object = Record<string, unknown>, Proxify extends boolean = true> = Proxify extends true ? ProxifiedRemoteFunctions<RemoteFunctions> & BirpcReturnBuiltin<RemoteFunctions, LocalFunctions> : BirpcReturnBuiltin<RemoteFunctions, LocalFunctions>;
+type PendingCallHandler = (options: Pick<PromiseEntry, 'method' | 'reject'>) => void | Promise<void>;
+interface PromiseEntry {
+  resolve: (arg: any) => void;
+  reject: (error: any) => void;
+  method: string;
+  timeoutId?: ReturnType<typeof setTimeout>;
+}
+declare const setTimeout: any;
+//#endregion
+//#region src/group.d.ts
+interface BirpcGroupReturnBuiltin<RemoteFunctions> {
+  /**
+   * Call the remote function and wait for the result.
+   * An alternative to directly calling the function
+   */
+  $call: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<Awaited<ReturnType<RemoteFunctions[K]>>[]>;
+  /**
+   * Same as `$call`, but returns `undefined` if the function is not defined on the remote side.
+   */
+  $callOptional: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<(Awaited<ReturnType<RemoteFunctions[K]>> | undefined)[]>;
+  /**
+   * Send event without asking for response
+   */
+  $callEvent: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<void>;
+  /**
+   * Call the remote function with the raw options.
+   */
+  $callRaw: (options: {
+    method: string;
+    args: unknown[];
+    event?: boolean;
+    optional?: boolean;
+  }) => Promise<Awaited<ReturnType<any>>[]>;
+}
+type BirpcGroupReturn<RemoteFunctions extends object = Record<string, unknown>, Proxify extends boolean = true> = Proxify extends true ? ProxifiedRemoteFunctions<RemoteFunctions> & BirpcGroupReturnBuiltin<RemoteFunctions> : BirpcGroupReturnBuiltin<RemoteFunctions>;
+interface BirpcGroup<RemoteFunctions extends object = Record<string, unknown>, LocalFunctions extends object = Record<string, unknown>, Proxify extends boolean = true> {
+  readonly clients: BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>[];
+  readonly functions: LocalFunctions;
+  readonly broadcast: BirpcGroupReturn<RemoteFunctions, Proxify>;
+  updateChannels: (fn?: ((channels: ChannelOptions[]) => void)) => BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>[];
+}
+//#endregion
+export { ChannelOptions as a, BirpcReturn as i, BirpcGroup as n, EventOptions as o, BirpcOptions as r, BirpcFn as t };

package/dist/{index-r6NstVmM.d.mts → index-CcPSKbxb.d.mts}

@@ -1,5 +1,5 @@
-import { k as SharedState, o as DevframeNodeContext, s as DevframeNodeRpcSession } from "./context-BLHBDQcZ.mjs";
-import { n as InternalAnonymousAuthStorage } from "./context-BA5FPz7K.mjs";
+import { k as SharedState, o as DevframeNodeContext, s as DevframeNodeRpcSession } from "./context-CTAxz9ec.mjs";
+import { n as InternalAnonymousAuthStorage } from "./context-B4BKPuaa.mjs";
 //#region src/node/auth/revoke.d.ts
 /**
  * Flip `isTrusted` to false on any live WS clients connected with `token`

package/dist/index-CeEtxDmK.d.mts

@@ -0,0 +1,78 @@
+//#region ../../node_modules/.pnpm/@standard-schema+spec@1.1.0/node_modules/@standard-schema/spec/dist/index.d.ts
+/** The Standard Typed interface. This is a base type extended by other specs. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard Typed properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard Typed types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Typed. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Typed. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+//#endregion
+export { StandardSchemaV1 as t };

package/dist/{index-CiA6C705.d.mts → index-DuEm0sDH.d.mts}

@@ -1,4 +1,4 @@
-import { D as RpcReturnSchema, E as RpcFunctionsCollector, T as RpcFunctionType, _ as RpcFunctionDefinition, i as RpcArgsSchema, v as RpcFunctionDefinitionAny, w as RpcFunctionSetupResult } from "./types-D2vGd7-2.mjs";
+import { C as RpcFunctionType, S as RpcFunctionSetupResult, T as RpcReturnSchema, g as RpcFunctionDefinitionAny, h as RpcFunctionDefinition, n as RpcArgsSchema, w as RpcFunctionsCollector } from "./types-BmDbfHCx.mjs";
 //#region src/rpc/cache.d.ts
 interface RpcCacheOptions {
   functions: string[];

package/dist/index.d.mts

@@ -1,9 +1,8 @@
-import "./index-CiA6C705.mjs";
-import { D as RpcReturnSchema, T as RpcFunctionType, _ as RpcFunctionDefinition, g as RpcFunctionAgentOptions, i as RpcArgsSchema } from "./types-D2vGd7-2.mjs";
-import { $ as DevframeServiceOf, At as AgentHandle, B as DevframeSetupInfo, Bt as DevframeAgentHostEvents, Ct as DevframeDiagnosticsHost, F as DevframeDefinition, Ft as AgentTool, G as McpAuthorization, H as DevframeSnapshotRpcInputs, Ht as EventUnsubscribe, I as DevframeDeploymentKind, It as AgentToolInput, J as DevframeServiceDefinition, K as McpRouteOptions, L as DevframeDockDefaults, Lt as AgentToolProvider, Mt as AgentResource, Nt as AgentResourceContent, P as DevframeCliOptions, Pt as AgentResourceInput, Q as DevframeServiceMeta, R as DevframeDuplicationStrategy, Rt as AgentToolProviderHandle, St as DevframeStorageScope, U as DevframeSseOptions, Ut as EventsMap, V as DevframeSnapshotRpcEntry, Vt as EventEmitter, W as DevframeWsOptions, X as DevframeServiceId, Y as DevframeServiceDescriptor, Z as DevframeServiceInput, _t as DevframeViewHost, a as DevframeConnectionConfigsRegistry, at as DevframeScopedNodeContext, bt as DevframeRpcSharedStates, c as RpcBroadcastOptions, ct as DevframeSettings, d as RpcSharedStateHost, dt as ScopedBroadcastOptions, et as DevframeServiceScopeOf, f as RpcStreamingChannel, ft as ScopedClientFunctions, gt as SettingsForNamespace, ht as ScopedSharedStates, i as DevframeCapabilities, it as DevframeServicesState, jt as AgentManifest, l as RpcFunctionsHost, lt as DevframeSettingsRegistry, m as RpcStreamingHost, mt as ScopedServerFunctions, n as ConnectionMetaSse, nt as DevframeServicesRegistry, o as DevframeNodeContext, ot as DevframeScopedNodeRpc, p as RpcStreamingChannelOptions, pt as ScopedRpcFn, q as McpSetting, r as ConnectionMetaWebsocket, rt as DevframeServicesScopeRegistry, s as DevframeNodeRpcSession, st as DevframeScopedStreamingHost, t as ConnectionMeta, tt as DevframeServicesHost, u as RpcSharedStateGetOptions, ut as DevframeSettingsStore, vt as DevframeRpcClientFunctions, wt as DevframeDiagnosticsLogger, xt as DevframeHost, yt as DevframeRpcServerFunctions, z as DevframeRpcOptions, zt as DevframeAgentHost } from "./context-BLHBDQcZ.mjs";
+import { C as RpcFunctionType, T as RpcReturnSchema, h as RpcFunctionDefinition, m as RpcFunctionAgentOptions, n as RpcArgsSchema } from "./types-BmDbfHCx.mjs";
+import { $ as DevframeServiceDefinition, B as DevframeDefinition, Bt as AgentTool, Ct as DevframeRpcClientFunctions, Dt as DevframeStorageScope, Et as DevframeHost, F as CreateMcpServerOptions, Ft as AgentHandle, G as DevframeSetupInfo, Gt as DevframeAgentHostEvents, H as DevframeDockDefaults, Ht as AgentToolProvider, I as McpConnectionInfo, It as AgentManifest, J as DevframeSseOptions, Jt as EventsMap, K as DevframeSnapshotRpcEntry, Kt as EventEmitter, L as McpFetchHandler, Lt as AgentResource, Ot as DevframeDiagnosticsHost, P as CreateMcpFetchHandlerOptions, Q as McpSetting, R as McpServerHandle, Rt as AgentResourceContent, St as DevframeViewHost, Tt as DevframeRpcSharedStates, U as DevframeDuplicationStrategy, Ut as AgentToolProviderHandle, V as DevframeDeploymentKind, Vt as AgentToolInput, W as DevframeRpcOptions, Wt as DevframeAgentHost, X as McpAuthorization, Y as DevframeWsOptions, Z as McpRouteOptions, _t as ScopedClientFunctions, a as DevframeConnectionConfigsRegistry, at as DevframeServiceScopeOf, bt as ScopedSharedStates, c as RpcBroadcastOptions, ct as DevframeServicesScopeRegistry, d as RpcSharedStateHost, dt as DevframeScopedNodeRpc, et as DevframeServiceDescriptor, f as RpcStreamingChannel, ft as DevframeScopedStreamingHost, gt as ScopedBroadcastOptions, ht as DevframeSettingsStore, i as DevframeCapabilities, it as DevframeServiceOf, kt as DevframeDiagnosticsLogger, l as RpcFunctionsHost, lt as DevframeServicesState, m as RpcStreamingHost, mt as DevframeSettingsRegistry, n as ConnectionMetaSse, nt as DevframeServiceInput, o as DevframeNodeContext, ot as DevframeServicesHost, p as RpcStreamingChannelOptions, pt as DevframeSettings, q as DevframeSnapshotRpcInputs, qt as EventUnsubscribe, r as ConnectionMetaWebsocket, rt as DevframeServiceMeta, s as DevframeNodeRpcSession, st as DevframeServicesRegistry, t as ConnectionMeta, tt as DevframeServiceId, u as RpcSharedStateGetOptions, ut as DevframeScopedNodeContext, vt as ScopedRpcFn, wt as DevframeRpcServerFunctions, xt as SettingsForNamespace, yt as ScopedServerFunctions, z as DevframeCliOptions, zt as AgentResourceInput } from "./context-CTAxz9ec.mjs";
 import { a as DevframeWsPeer, i as DevframeRpcTransportKind, n as DevframeRpcConnection, r as DevframeRpcConnectionRequest, t as DevframeNodeRpcSessionMeta } from "./session-r6PDixP6.mjs";
 import { a as RemoteAssetsStore, i as RemoteAssetsProviderCustom, n as RemoteAssetsErrorMessage, o as StaticAssetsSource, r as RemoteAssetsProvider, t as RemoteAssets } from "./remote-assets-eBvSKZMS.mjs";
-import { i as DevframeDefineDiagnosticsOptions } from "./nostics-0sKe5HIj.mjs";
+import { i as DevframeDefineDiagnosticsOptions } from "./nostics-DWvukRwa.mjs";
 //#region src/define.d.ts
 export 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, DevframeNodeContext>) => RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, DevframeNodeContext>;
 /**
@@ -11,11 +10,5 @@ export declare const defineRpcFunction: <NAME extends string, TYPE extends RpcFu
  * entry point. Import it from the package root: `import { defineDevframe } from 'devframe'`.
  */
 export declare function defineDevframe(d: DevframeDefinition): DevframeDefinition;
-/**
- * @deprecated Read {@link DevframeDefinition.clientAssets} from the definition
- * directly. This helper is internal machinery that was never meant to be part
- * of the public API and is scheduled for removal.
- */
-export declare function resolveClientAssets(d: DevframeDefinition): StaticAssetsSource | undefined;
 //#endregion
-export type { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, AgentToolProvider, AgentToolProviderHandle, ConnectionMeta, ConnectionMetaSse, ConnectionMetaWebsocket, DevframeAgentHost, DevframeAgentHostEvents, DevframeCapabilities, DevframeCliOptions, DevframeConnectionConfigsRegistry, DevframeDefineDiagnosticsOptions, DevframeDefinition, DevframeDeploymentKind, DevframeDiagnosticsHost, DevframeDiagnosticsLogger, DevframeDockDefaults, DevframeDuplicationStrategy, DevframeHost, DevframeNodeContext, DevframeNodeRpcSession, DevframeNodeRpcSessionMeta, DevframeRpcClientFunctions, DevframeRpcConnection, DevframeRpcConnectionRequest, DevframeRpcOptions, DevframeRpcServerFunctions, DevframeRpcSharedStates, DevframeRpcTransportKind, DevframeScopedNodeContext, DevframeScopedNodeRpc, DevframeScopedStreamingHost, DevframeServiceDefinition, DevframeServiceDescriptor, DevframeServiceId, DevframeServiceInput, DevframeServiceMeta, DevframeServiceOf, DevframeServiceScopeOf, DevframeServicesHost, DevframeServicesRegistry, DevframeServicesScopeRegistry, DevframeServicesState, DevframeSettings, DevframeSettingsRegistry, DevframeSettingsStore, DevframeSetupInfo, DevframeSnapshotRpcEntry, DevframeSnapshotRpcInputs, DevframeSseOptions, DevframeStorageScope, DevframeViewHost, DevframeWsOptions, DevframeWsPeer, EventEmitter, EventUnsubscribe, EventsMap, McpAuthorization, McpRouteOptions, McpSetting, RemoteAssets, RemoteAssetsErrorMessage, RemoteAssetsProvider, RemoteAssetsProviderCustom, RemoteAssetsStore, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, ScopedBroadcastOptions, ScopedClientFunctions, ScopedRpcFn, ScopedServerFunctions, ScopedSharedStates, SettingsForNamespace, StaticAssetsSource };
+export type { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, AgentToolProvider, AgentToolProviderHandle, ConnectionMeta, ConnectionMetaSse, ConnectionMetaWebsocket, CreateMcpFetchHandlerOptions, CreateMcpServerOptions, DevframeAgentHost, DevframeAgentHostEvents, DevframeCapabilities, DevframeCliOptions, DevframeConnectionConfigsRegistry, DevframeDefineDiagnosticsOptions, DevframeDefinition, DevframeDeploymentKind, DevframeDiagnosticsHost, DevframeDiagnosticsLogger, DevframeDockDefaults, DevframeDuplicationStrategy, DevframeHost, DevframeNodeContext, DevframeNodeRpcSession, DevframeNodeRpcSessionMeta, DevframeRpcClientFunctions, DevframeRpcConnection, DevframeRpcConnectionRequest, DevframeRpcOptions, DevframeRpcServerFunctions, DevframeRpcSharedStates, DevframeRpcTransportKind, DevframeScopedNodeContext, DevframeScopedNodeRpc, DevframeScopedStreamingHost, DevframeServiceDefinition, DevframeServiceDescriptor, DevframeServiceId, DevframeServiceInput, DevframeServiceMeta, DevframeServiceOf, DevframeServiceScopeOf, DevframeServicesHost, DevframeServicesRegistry, DevframeServicesScopeRegistry, DevframeServicesState, DevframeSettings, DevframeSettingsRegistry, DevframeSettingsStore, DevframeSetupInfo, DevframeSnapshotRpcEntry, DevframeSnapshotRpcInputs, DevframeSseOptions, DevframeStorageScope, DevframeViewHost, DevframeWsOptions, DevframeWsPeer, EventEmitter, EventUnsubscribe, EventsMap, McpAuthorization, McpConnectionInfo, McpFetchHandler, McpRouteOptions, McpServerHandle, McpSetting, RemoteAssets, RemoteAssetsErrorMessage, RemoteAssetsProvider, RemoteAssetsProviderCustom, RemoteAssetsStore, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, ScopedBroadcastOptions, ScopedClientFunctions, ScopedRpcFn, ScopedServerFunctions, ScopedSharedStates, SettingsForNamespace, StaticAssetsSource };

package/dist/index.mjs

@@ -1,5 +1,4 @@
 import { t as createDefineWrapperWithContext } from "./define-BLWPsH6y.mjs";
-import { t as resolveClientAssets$1 } from "./client-assets-DNdhagGm.mjs";
 //#region src/define.ts
 const defineRpcFunction = createDefineWrapperWithContext();
 /**
@@ -9,13 +8,5 @@ const defineRpcFunction = createDefineWrapperWithContext();
 function defineDevframe(d) {
 	return d;
 }
-/**
-* @deprecated Read {@link DevframeDefinition.clientAssets} from the definition
-* directly. This helper is internal machinery that was never meant to be part
-* of the public API and is scheduled for removal.
-*/
-function resolveClientAssets(d) {
-	return resolveClientAssets$1(d);
-}
 //#endregion
-export { defineDevframe, defineRpcFunction, resolveClientAssets };
+export { defineDevframe, defineRpcFunction };

package/dist/{instance-registry-DCq762YJ.mjs → instance-registry-DtvYxc0Y.mjs}

@@ -1,5 +1,5 @@
 import { n as __exportAll } from "./rolldown-runtime-B4iAMlE-.mjs";
-import { t as diagnostics } from "./diagnostics-DZA6KQ_Z.mjs";
+import { t as diagnostics } from "./diagnostics-Cx4_VjlG.mjs";
 import { join } from "pathe";
 import process from "node:process";
 import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";

package/dist/{instance-shell-C6Vg97lg.d.mts → instance-shell-DOZSxst6.d.mts}

@@ -1,8 +1,8 @@
-import { Tt as DevframeAuthHandler, U as DevframeSseOptions, W as DevframeWsOptions, o as DevframeNodeContext, s as DevframeNodeRpcSession, t as ConnectionMeta, vt as DevframeRpcClientFunctions, yt as DevframeRpcServerFunctions } from "./context-BLHBDQcZ.mjs";
+import { n as BirpcGroup } from "./index-Bia1vKjL.mjs";
+import { At as DevframeAuthHandler, Ct as DevframeRpcClientFunctions, J as DevframeSseOptions, Y as DevframeWsOptions, o as DevframeNodeContext, s as DevframeNodeRpcSession, t as ConnectionMeta, wt as DevframeRpcServerFunctions } from "./context-CTAxz9ec.mjs";
 import { n as DevframeRpcConnection, t as DevframeNodeRpcSessionMeta } from "./session-r6PDixP6.mjs";
-import { n as WsOriginRegistry } from "./ws-server-BB8jhxeT.mjs";
-import "./index-r6NstVmM.mjs";
-import { BirpcGroup } from "birpc";
+import { n as WsOriginRegistry } from "./ws-server-y2R76aSW.mjs";
+import "./index-CcPSKbxb.mjs";
 import { H3 } from "h3";
 import { NodeAdapter } from "crossws/adapters/node";
 import { Buffer } from "node:buffer";
@@ -65,6 +65,32 @@ interface DevframeInstanceRegistration {
 declare function registerDevframeInstance(record: DevframeInstanceRecord, options?: {
   instancesDir?: string;
 }): DevframeInstanceRegistration;
+/**
+ * A successful `__connection.json` probe: the dialable origin that
+ * answered plus the parsed connection meta it served.
+ *
+ * @internal
+ */
+interface ProbedDevframeOrigin {
+  /** The origin that answered (may be an explicit address family for a `localhost` bind). */
+  origin: string;
+  /** The parsed `__connection.json` payload (`{}` when unparseable). */
+  meta: {
+    mcp?: {
+      path: string;
+      port?: number;
+    };
+  };
+}
+/**
+ * Probe `<origin><basePath>__connection.json`, trying each dialable
+ * candidate for the origin (see {@link originCandidates}). The single
+ * probe primitive behind both registry liveness checks and the
+ * connector's explicit `--port` probes.
+ *
+ * @internal
+ */
+declare function probeDevframeOrigin(origin: string, basePath: string, timeoutMs?: number): Promise<ProbedDevframeOrigin | null>;
 /**
  * Read the registry and split records into live and dead by probing each
  * one's `__connection.json`, deleting dead records (prune-on-read). Live
@@ -260,4 +286,4 @@ declare function samePath(a: string, b: string): boolean;
  */
 declare function createInstanceShell<TContext extends DevframeNodeContext>(options: CreateInstanceShellOptions<TContext>): InstanceShell<TContext>;
 //#endregion
-export { InstanceShellInit as a, StartedServer as c, samePath as d, DevframeInstanceRecord as f, registerDevframeInstance as h, InstanceShellApi as i, createInstanceShell as l, listLiveDevframeInstances as m, InstanceRegisterConfig as n, InstanceShellInternals as o, DevframeInstanceRegistration as p, InstanceShell as r, InstanceWsTier as s, CreateInstanceShellOptions as t, resolveInstanceRegister as u };
+export { InstanceShellInit as a, StartedServer as c, samePath as d, DevframeInstanceRecord as f, registerDevframeInstance as g, probeDevframeOrigin as h, InstanceShellApi as i, createInstanceShell as l, listLiveDevframeInstances as m, InstanceRegisterConfig as n, InstanceShellInternals as o, DevframeInstanceRegistration as p, InstanceShell as r, InstanceWsTier as s, CreateInstanceShellOptions as t, resolveInstanceRegister as u };

package/dist/{instance-shell-yfrM3_vK.mjs → instance-shell-wC2sfEU_.mjs}

@@ -1,12 +1,12 @@
 import "./constants.mjs";
-import { i as validateOriginCandidate } from "./origin-D_eBKEzr.mjs";
-import { t as diagnostics } from "./diagnostics-DZA6KQ_Z.mjs";
-import { t as getInternalContext } from "./context-jXO5vzjH.mjs";
-import { createInteractiveAuth } from "./recipes/interactive-auth.mjs";
+import { r as validateOriginCandidate } from "./origin-DZit9g29.mjs";
+import { t as diagnostics } from "./diagnostics-Cx4_VjlG.mjs";
+import { c as joinURL, d as withoutLeadingSlash, f as withoutTrailingSlash, u as withLeadingSlash } from "./_shared-B2PZsp-J.mjs";
+import { t as getInternalContext } from "./context-CHpyLX8W.mjs";
+import { n as createInteractiveAuth } from "./interactive-auth-BCa_iamv.mjs";
 import { createServer } from "node:http";
 import process from "node:process";
 import { isIP } from "node:net";
-import { joinURL, withLeadingSlash, withoutLeadingSlash, withoutTrailingSlash } from "ufo";
 import { H3, defineHandler, toNodeHandler } from "h3";
 //#region src/node/runtime.ts
 /**
@@ -311,7 +311,7 @@ function createInstanceShell(options) {
 		const origin = currentOrigin();
 		if (!cfg || registerPromise || !origin || !meta) return;
 		const resolvedMeta = meta;
-		registerPromise = import("./instance-registry-DCq762YJ.mjs").then((n) => n.t).then(({ registerDevframeInstance }) => {
+		registerPromise = import("./instance-registry-DtvYxc0Y.mjs").then((n) => n.t).then(({ registerDevframeInstance }) => {
 			let port = 0;
 			try {
 				const url = new URL(origin);
@@ -387,7 +387,7 @@ function createInstanceShell(options) {
 	let resolvedAuth = false;
 	let corePromise;
 	function ensureCore() {
-		corePromise ??= import("./rpc-core-CvkU23bQ.mjs").then((n) => n.n).then(({ createContextRpcServer }) => createContextRpcServer({
+		corePromise ??= import("./rpc-core-BXyMjbKG.mjs").then((n) => n.n).then(({ createContextRpcServer }) => createContextRpcServer({
 			context: ctx,
 			auth: resolvedAuth,
 			onPeerConnect: options.onPeerConnect,