likec4 1.56.0 → 1.58.0

package/dist/index.d.mts

@@ -1,129 +1,7 @@
 import { i as __name } from "./chunks/rolldown-runtime.mjs";
-import { t as Logger } from "./chunks/libs/@logtape/logtape.mjs";
-import { a as LikeC4Views, i as LikeC4SharedServices, n as LikeC4ModelBuilder, o as ProjectsManager, r as LikeC4Services, t as LikeC4LanguageServices } from "./chunks/index2.mjs";
-import { LayoutedView, NonEmptyArray, ProjectId } from "@likec4/core/types";
-import { LikeC4Model } from "@likec4/core/model";
-export * from "@likec4/core/types";
+import { t as LikeC4$1 } from "./chunks/index2.mjs";
+export type * from "@likec4/core/types";
 
-//#region ../language-services/dist/_chunks/options.d.mts
-//#region src/common/LikeC4.d.ts
-interface LikeC4Langium {
-  shared: LikeC4SharedServices;
-  likec4: LikeC4Services;
-}
-declare class LikeC4$1 {
-  protected readonly langium: LikeC4Langium;
-  protected readonly logger: Logger;
-  constructor(langium: LikeC4Langium, logger?: Logger);
-  /**
-   * File system path to the workspace root
-   */
-  get workspace(): any;
-  /**
-   * URI of the workspace root
-   */
-  get workspaceURI(): any;
-  /**
-   * URL of the workspace root
-   */
-  get workspaceURL(): any;
-  get languageServices(): LikeC4LanguageServices;
-  get projectsManager(): ProjectsManager;
-  get viewsService(): LikeC4Views;
-  get modelBuilder(): LikeC4ModelBuilder;
-  private get LangiumDocuments();
-  ensureSingleProject(): void;
-  /**
-   * Diagram is a computed view, layouted using Graphviz
-   * If diagram has manual layout, it will be used.
-   * Used in React components
-   */
-  diagrams(project?: string | undefined): Promise<LayoutedView[]>;
-  /**
-   * Builds LikeC4Model from all documents
-   * Only computes view predicates {@link ComputedView} - i.e. no layout
-   * Not ready for rendering, but enough to traverse
-   *
-   * Sync version does not read manual layouts
-   * Use {@link computedModel} for a version that includes manual layouts
-   */
-  syncComputedModel(project?: string | undefined): LikeC4Model.Computed;
-  /**
-   * Builds LikeC4Model from all documents
-   * Only computes view predicates {@link ComputedView} - i.e. no layout
-   * Not ready for rendering, but enough to traverse
-   */
-  computedModel(project?: string | undefined): Promise<LikeC4Model.Computed>;
-  projects(): NonEmptyArray<ProjectId>;
-  /**
-   * Same as {@link computedModel()}, but also applies layout
-   * Ready for rendering
-   */
-  layoutedModel(project?: string | undefined): Promise<LikeC4Model.Layouted>;
-  getErrors(): Array<{
-    message: string;
-    line: number;
-    range: {
-      start: {
-        line: number;
-        character: number;
-      };
-      end: {
-        line: number;
-        character: number;
-      };
-    };
-    sourceFsPath: string;
-  }>;
-  hasErrors(): boolean;
-  /**
-   * @returns true if there are errors
-   */
-  printErrors(): boolean;
-  /**
-   * Returns the number of parsed documents in the workspace
-   */
-  documentCount(): number;
-  /**
-   * @returns a function to dispose the listener
-   */
-  onModelUpdate(listener: () => void): () => void;
-  /**
-   * Formats documents and returns a map of document URI → formatted source text.
-   *
-   * Target selection uses union semantics:
-   * - Omit both `projects` and `documentUris` to format **all** documents.
-   * - Provide `projects` to include all documents from those projects.
-   * - Provide `documentUris` to include specific documents.
-   * - Provide both to format the **union** (deduplicated).
-   */
-  format(options?: LikeC4FormatOptions): Promise<Map<string, string>>;
-  dispose(): Promise<void>;
-  [Symbol.asyncDispose](): Promise<void>;
-}
-/**
- * Options for {@link LikeC4.format}.
- *
- * Same as {@link FormatOptions} but uses project name strings instead of {@link ProjectId}.
- */
-interface LikeC4FormatOptions {
-  /** Include all documents from these projects (by name). */
-  projects?: ReadonlyArray<string>;
-  /** Include these specific documents (by URI string). */
-  documentUris?: ReadonlyArray<string>;
-  /** Size of a tab in spaces (default: 2). */
-  tabSize?: number;
-  /** Prefer spaces over tabs (default: true). */
-  insertSpaces?: boolean;
-  /** Trim trailing whitespace on a line. */
-  trimTrailingWhitespace?: boolean;
-  /** Insert a newline character at the end of the file if one does not exist. */
-  insertFinalNewline?: boolean;
-  /** Trim all newlines after the final newline at the end of the file. */
-  trimFinalNewlines?: boolean;
-} //#endregion
-//#region src/common/options.d.ts
-//#endregion
 //#region src/LikeC4.d.ts
 type LikeC4Options = {
   /**
@@ -150,13 +28,6 @@ type LikeC4Options = {
    * @default 'wasm'
    */
   graphviz?: 'wasm' | 'binary';
-  /**
-   * Whether to start MCP server
-   * @default false
-   */
-  mcp?: false | 'stdio' | {
-    port: number;
-  };
   /**
    * Whether to watch for changes in the workspace.
    * @default false

package/dist/index.mjs

@@ -1 +1 @@
-import{i as e}from"./chunks/rolldown-runtime.mjs";import{n as t,t as n}from"./chunks/node.mjs";import{t as r}from"./chunks/libs/defu.mjs";import{exact as i}from"@likec4/core";let a;(function(a){async function fromSource$1(e,t){let{logger:a,watch:o,...s}=t??{};return n(e,r(i({...s,configureLogger:a}),{configureLogger:`console`}))}e(fromSource$1,`fromSource`),a.fromSource=fromSource$1;async function fromWorkspace$1(e=``,n){let{logger:a,watch:o,...s}=n??{};return t(e,r(i({...s,configureLogger:a}),{configureLogger:`console`}))}e(fromWorkspace$1,`fromWorkspace`),a.fromWorkspace=fromWorkspace$1})(a||={});export{a as LikeC4};
+import{i as e}from"./chunks/rolldown-runtime.mjs";import{l as t,n,t as r}from"./chunks/node.mjs";import{exact as i}from"@likec4/core";let a;(function(a){async function fromSource$1(e,n){let{logger:a,watch:o,...s}=n??{};return r(e,t(i({...s,configureLogger:a}),{configureLogger:`console`}))}e(fromSource$1,`fromSource`),a.fromSource=fromSource$1;async function fromWorkspace$1(e=``,r){let{logger:a,watch:o,...s}=r??{};return n(e,t(i({...s,configureLogger:a}),{configureLogger:`console`}))}e(fromWorkspace$1,`fromWorkspace`),a.fromWorkspace=fromWorkspace$1})(a||={});export{a as LikeC4};

package/dist/model/index.d.mts

@@ -1,9 +1,9 @@
 import { i as __name } from "../chunks/rolldown-runtime.mjs";
 import * as types from "@likec4/core/types";
-import { BBox, LayoutedDynamicView, NodeId, ViewId } from "@likec4/core/types";
+import { BBox, EdgeId, LayoutedDynamicView, NodeId, ViewId } from "@likec4/core/types";
 import { Connection, ConnectionModel, DeployedInstanceModel, DeploymentConnectionModel, DeploymentElementModel, DeploymentNodeModel, DeploymentRelationEndpoint, DeploymentRelationModel, EdgeModel, ElementModel, LikeC4DeploymentModel, LikeC4Model, LikeC4Model as LikeC4Model$1, LikeC4ViewModel, NodeModel, RelationshipModel, deploymentConnection, differenceConnections, findAscendingConnections, findDeepestNestedConnection, findDescendantConnections, hasSameSource, hasSameSourceTarget, hasSameTarget, isAnyInOut, isDeployedInstanceModel, isDeploymentElementModel, isDeploymentNodeModel, isDeploymentRelationModel, isEdgeModel, isElementModel, isIncoming, isLikeC4ViewModel, isNestedConnection, isNestedElementOfDeployedInstanceModel, isNodeModel, isOutgoing, isRelationModel, mergeConnections, modelConnection, sortConnectionsByBoundaryHierarchy, sortDeepestFirst } from "@likec4/core/model";
 import { ComputedProjectEdge, ComputedProjectNode, ComputedProjectsView, LayoutedProjectEdge, LayoutedProjectNode, LayoutedProjectsView } from "@likec4/core/compute-view";
-export * from "@likec4/core/types";
+export type * from "@likec4/core/types";
 
 //#region ../layouts/dist/sequence/index.d.mts
 //#region src/sequence/_types.d.ts

package/dist/vite-plugin/index.d.mts

@@ -1,6 +1,7 @@
 import { i as __name } from "../chunks/rolldown-runtime.mjs";
-import { t as LikeC4LanguageServices } from "../chunks/index2.mjs";
+import { n as LikeC4LanguageServices } from "../chunks/index2.mjs";
 import { PluginOption } from "vite";
+import { AnyTextAdapter } from "@tanstack/ai";
 
 //#region ../vite-plugin/dist/index.d.mts
 //#region src/virtuals/app-config.d.ts
@@ -27,7 +28,56 @@ interface AppConfig {
   theme?: 'light' | 'dark' | undefined;
 } //#endregion
 //#region src/plugin.d.ts
+interface AIOptions<TAdapter extends AnyTextAdapter = AnyTextAdapter> {
+  /**
+   * The AI adapter to use
+   *
+   * @see https://tanstack.com/ai/latest/docs/getting-started/overview#adapters
+   * @example
+   * ```ts
+   * import { openRouterText } from '@tanstack/ai-openrouter'
+   *
+   * export default defineConfig({
+   *   plugins: [
+   *     likec4VitePlugin({
+   *       ai: {
+   *         adapter: openRouterText("openai/gpt-5")
+   *       },
+   *     }),
+   *   ],
+   * })
+   * ```
+   */
+  adapter: TAdapter;
+  /** Model-specific provider options (type comes from adapter) */
+  modelOptions?: TAdapter['~types']['providerOptions'];
+  maxTokens?: number;
+}
 type SharedOptions = {
+  /**
+   * AI configuration, by default enabled with automatic detection based on environment variables.
+   * You can also provide explicit configuration.
+   * Or set to `disabled` to disable AI.
+   *
+   * @default 'auto' (automatic detection based on environment variables)
+   *
+   * @see https://tanstack.com/ai/latest/docs/getting-started/overview#adapters
+   * @example
+   * ```ts
+   * import { openRouterText } from '@tanstack/ai-openrouter'
+   *
+   * export default defineConfig({
+   *   plugins: [
+   *     likec4VitePlugin({
+   *       ai: {
+   *         adapter: openRouterText("openai/gpt-5")
+   *       },
+   *     }),
+   *   ],
+   * })
+   * ```
+   */
+  ai?: 'disabled' | 'auto' | AIOptions | undefined;
   /**
    * Define vite environments where this plugin should be active
    * By default, the plugin is active in all environments
@@ -89,7 +139,8 @@ type LikeC4VitePluginOptions = SharedOptions & ({
 declare function LikeC4VitePlugin({
   environments,
   appConfig,
-  ...opts
+  ai: _ai,
+  ...pluginOpts
 }: LikeC4VitePluginOptions): PluginOption; //#endregion
 //#endregion
 export { LikeC4VitePlugin, type LikeC4VitePluginOptions };

package/dist/vite-plugin/index.mjs

@@ -1 +1 @@
-import{t as e}from"../chunks/plugin.mjs";export{e as LikeC4VitePlugin};
+import{t as e}from"../chunks/vite-plugin.mjs";export{e as LikeC4VitePlugin};

package/dist/vite-plugin/internal/index.d.mts

@@ -1,13 +1,289 @@
-import { t as __name } from "./chunks/rolldown-runtime.mjs";
-import { a as map, c as WritableAtom, l as atom, o as Atom, s as ReadableAtom, t as useStore } from "./chunks/libs/@nanostores/react.mjs";
-import { n as computed, t as batched } from "./chunks/libs/nanostores.mjs";
 import { LikeC4Model } from "@likec4/core/model";
+import { DependencyList } from "react";
 import { LayoutedElementView, LayoutedLikeC4ModelData, LayoutedView, ProjectId, ViewChange, ViewId } from "@likec4/core/types";
 import { AdhocViewPredicate } from "@likec4/core/compute-view";
 
-//#region ../vite-plugin/dist/internal.d.mts
+//#region ../vite-plugin/dist/internal/index.d.mts
+//#region ../../node_modules/.pnpm/nanostores@1.3.0/node_modules/nanostores/atom/index.d.ts
+type AllKeys<T> = T extends any ? keyof T : never;
+type Primitive = boolean | number | string;
+type ReadonlyIfObject<Value> = Value extends undefined ? Value : Value extends ((...args: any) => any) ? Value : Value extends Primitive ? Value : Value extends object ? Readonly<Value> : Value;
+/**
+ * Store object.
+ */
+interface ReadableAtom<Value = any> {
+  /**
+   * Get store value.
+   *
+   * In contrast with {@link ReadableAtom#value} this value will be always
+   * initialized even if store had no listeners.
+   *
+   * ```js
+   * $store.get()
+   * ```
+   *
+   * @returns Store value.
+   */
+  get(): Value;
+  /**
+   * Low-level attribute to read store’s initial value.
+   */
+  readonly init: undefined | Value;
+  /**
+   * Listeners count.
+   */
+  readonly lc: number;
+  /**
+   * Subscribe to store changes.
+   *
+   * In contrast with {@link Store#subscribe} it do not call listener
+   * immediately.
+   *
+   * @param listener Callback with store value and old value.
+   * @returns Function to remove listener.
+   */
+  listen(listener: (value: ReadonlyIfObject<Value>, oldValue: ReadonlyIfObject<Value>) => void): () => void;
+  /**
+   * Low-level method to notify listeners about changes in the store.
+   *
+   * Can cause unexpected behaviour when combined with frontend frameworks
+   * that perform equality checks for values, such as React.
+   */
+  notify(oldValue?: ReadonlyIfObject<Value>): void;
+  /**
+   * Unbind all listeners.
+   */
+  off(): void;
+  /**
+   * Subscribe to store changes and call listener immediately.
+   *
+   * ```
+   * import { $router } from '../store'
+   *
+   * $router.subscribe(page => {
+   *   console.log(page)
+   * })
+   * ```
+   *
+   * @param listener Callback with store value and old value.
+   * @returns Function to remove listener.
+   */
+  subscribe(listener: (value: ReadonlyIfObject<Value>, oldValue?: ReadonlyIfObject<Value>) => void): () => void;
+  /**
+   * Low-level method to read store’s value without calling `onStart`.
+   *
+   * Try to use only {@link ReadableAtom#get}.
+   * Without subscribers, value can be undefined.
+   */
+  readonly value: undefined | Value;
+}
+/**
+ * Store with a way to manually change the value.
+ */
+interface WritableAtom<Value = any> extends ReadableAtom<Value> {
+  /**
+   * Change store value.
+   *
+   * ```js
+   * $router.set({ path: location.pathname, page: parse(location.pathname) })
+   * ```
+   *
+   * @param newValue New store value.
+   */
+  set(newValue: Value): void;
+}
+interface PreinitializedWritableAtom<Value> extends WritableAtom<Value> {
+  readonly value: Value;
+}
+type Atom<Value = any> = ReadableAtom<Value> | WritableAtom<Value>;
+/**
+ * Create store with atomic value. It could be a string or an object, which you
+ * will replace completely.
+ *
+ * If you want to change keys in the object inside store, use {@link map}.
+ *
+ * ```js
+ * import { atom, onMount } from 'nanostores'
+ *
+ * // Initial value
+ * export const $router = atom({ path: '', page: 'home' })
+ *
+ * function parse () {
+ *   $router.set({ path: location.pathname, page: parse(location.pathname) })
+ * }
+ *
+ * // Listen for URL changes on first store’s listener.
+ * onMount($router, () => {
+ *   parse()
+ *   window.addEventListener('popstate', parse)
+ *   return () => {
+ *     window.removeEventListener('popstate', parse)
+ *   }
+ * })
+ * ```
+ *
+ * @param initialValue Initial value of the store.
+ * @returns The store object with methods to subscribe.
+ */
+declare function atom<Value, StoreExt = object>(...args: undefined extends Value ? [] | [Value] : [Value]): PreinitializedWritableAtom<Value> & StoreExt; //#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.3.0/node_modules/nanostores/map/index.d.ts
+type KeyofBase = keyof any;
+type Get<T, K extends KeyofBase> = Extract<T, { [K1 in K]: any }>[K];
+type HasIndexSignature<T> = string extends keyof T ? true : false;
+type ValueWithUndefinedForIndexSignatures<Value, Key extends keyof Value> = HasIndexSignature<Value> extends true ? undefined | Value[Key] : Value[Key];
+type WritableStore<Value = any> = (Value extends object ? MapStore<Value> : never) | WritableAtom<Value>;
+type Store<Value = any> = ReadableAtom<Value> | WritableStore<Value>;
+type AnyStore<Value = any> = {
+  get(): Value;
+  readonly value: undefined | Value;
+};
+type StoreValue<SomeStore> = SomeStore extends {
+  get(): infer Value;
+} ? Value : any;
+interface MapStore<Value extends object = any> extends WritableAtom<Value> {
+  /**
+   * Subscribe to store changes.
+   *
+   * In contrast with {@link Store#subscribe} it do not call listener
+   * immediately.
+   *
+   * @param listener Callback with store value and old value.
+   * @param changedKey Key that was changed. Will present only if `setKey`
+   *                   has been used to change a store.
+   * @returns Function to remove listener.
+   */
+  listen(listener: (value: ReadonlyIfObject<Value>, oldValue: ReadonlyIfObject<Value>, changedKey: AllKeys<Value>) => void): () => void;
+  /**
+   * Low-level method to notify listeners about changes in the store.
+   *
+   * Can cause unexpected behaviour when combined with frontend frameworks
+   * that perform equality checks for values, such as React.
+   */
+  notify(oldValue?: ReadonlyIfObject<Value>, changedKey?: AllKeys<Value>): void;
+  /**
+   * Change store value.
+   *
+   * ```js
+   * $settings.set({ theme: 'dark' })
+   * ```
+   *
+   * Operation is atomic, subscribers will be notified once with the new value.
+   * `changedKey` will be undefined
+   *
+   * @param newValue New store value.
+   */
+  set(newValue: Value): void;
+  /**
+   * Change key in store value.
+   *
+   * ```js
+   * $settings.setKey('theme', 'dark')
+   * ```
+   *
+   * To delete key set `undefined`.
+   *
+   * ```js
+   * $settings.setKey('theme', undefined)
+   * ```
+   *
+   * @param key The key name.
+   * @param value New value.
+   */
+  setKey<Key extends AllKeys<Value>>(key: Key, value: Get<Value, Key> | ValueWithUndefinedForIndexSignatures<Value, Key>): void;
+  /**
+   * Subscribe to store changes and call listener immediately.
+   *
+   * ```
+   * import { $router } from '../store'
+   *
+   * $router.subscribe(page => {
+   *   console.log(page)
+   * })
+   * ```
+   *
+   * @param listener Callback with store value and old value.
+   * @param changedKey Key that was changed. Will present only
+   *                   if `setKey` has been used to change a store.
+   * @returns Function to remove listener.
+   */
+  subscribe(listener: (value: ReadonlyIfObject<Value>, oldValue: ReadonlyIfObject<Value> | undefined, changedKey: AllKeys<Value> | undefined) => void): () => void;
+}
+interface PreinitializedMapStore<Value extends object = any> extends MapStore<Value> {
+  readonly value: Value;
+}
+/**
+ * Create map store. Map store is a store with key-value object
+ * as a store value.
+ *
+ * @param init Initialize store and return store destructor.
+ * @returns The store object with methods to subscribe.
+ */
+declare function map<Value extends object, StoreExt extends object = object>(value?: Value): PreinitializedMapStore<Value> & StoreExt; //#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.3.0/node_modules/nanostores/task/index.d.ts
+interface Task<Value> extends Promise<Value> {
+  t: true;
+} //#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.3.0/node_modules/nanostores/computed/index.d.ts
+type StoreValues<Stores extends AnyStore[]> = { [Index in keyof Stores]: StoreValue<Stores[Index]> };
+interface Computed {
+  /**
+   * @deprecated Use `@nanostores/async`.
+   */
+  <Value, OriginStore extends Store>(stores: OriginStore, cb: (value: StoreValue<OriginStore>) => Task<Value>): ReadableAtom<undefined | Value>;
+  /**
+   * @deprecated Use `@nanostores/async`.
+   */
+  <Value, OriginStores extends AnyStore[]>(stores: [...OriginStores], cb: (...values: StoreValues<OriginStores>) => Task<Value>): ReadableAtom<undefined | Value>;
+  <Value, OriginStore extends Store>(stores: OriginStore, cb: (value: StoreValue<OriginStore>) => Value): ReadableAtom<Value>;
+  /**
+   * Create derived store, which use generates value from another stores.
+   *
+   * ```js
+   * import { computed } from 'nanostores'
+   *
+   * import { $users } from './users.js'
+   *
+   * export const $admins = computed($users, users => {
+   *   return users.filter(user => user.isAdmin)
+   * })
+   * ```
+   *
+   * Use `@nanostores/async` for async function.
+   */
+  <Value, OriginStores extends AnyStore[]>(stores: [...OriginStores], cb: (...values: StoreValues<OriginStores>) => Task<Value> | Value): ReadableAtom<Value>;
+}
+declare const computed: Computed;
+interface Batched {
+  <Value, OriginStore extends Store>(stores: OriginStore, cb: (value: StoreValue<OriginStore>) => Task<Value> | Value): ReadableAtom<Value>;
+  /**
+   * Create derived store, which use generates value from another stores.
+   *
+   * ```js
+   * import { batched } from 'nanostores'
+   *
+   * const $sortBy = atom('id')
+   * const $category = atom('')
+   *
+   * export const $link = batched([$sortBy, $category], (sortBy, category) => {
+   *   return `/api/entities?sortBy=${sortBy}&category=${category}`
+   * })
+   * ```
+   */
+  <Value, OriginStores extends AnyStore[]>(stores: [...OriginStores], cb: (...values: StoreValues<OriginStores>) => Task<Value> | Value): ReadableAtom<Value>;
+}
+declare const batched: Batched; //#endregion
 //#region src/rpc/protocol.d.ts
 interface LikeC4VitePluginRpc {
+  /**
+   * Apply semantic layout (if AI is available)
+   * See vite-plugin for more details
+   *
+   * (Available in the dev server)
+   */
+  applySemanticLayout(payload: {
+    projectId: ProjectId;
+    viewId: ViewId;
+  }): Promise<void>;
   /**
    * Send a view change to the server
    * (Available in the dev server)
@@ -26,6 +302,53 @@ interface LikeC4VitePluginRpc {
     predicates: AdhocViewPredicate[];
   }): Promise<LayoutedElementView>;
 } //#endregion
+//#region ../../node_modules/.pnpm/@nanostores+react@1.1.0_nanostores@1.3.0_react@19.2.7/node_modules/@nanostores/react/index.d.ts
+type StoreKeys<T> = T extends {
+  setKey: (k: infer K, v: any) => unknown;
+} ? K : never;
+interface UseStoreOptions<SomeStore> {
+  /**
+   * @default
+   * ```ts
+   * [store, options.keys]
+   * ```
+   */
+  deps?: DependencyList;
+  /**
+   * Will re-render components only on specific key changes.
+   */
+  keys?: StoreKeys<SomeStore>[];
+  /**
+   * Enable SSR support. Set `initial` when store's initial value is the same on
+   * server and client, or provide a function to return the server store state
+   * for advanced cases (per useSyncExternalStore's getServerSnapshot).
+   */
+  ssr?: (() => StoreValue<SomeStore>) | 'initial' | false;
+}
+/**
+ * Subscribe to store changes and get store’s value.
+ *
+ * Can be user with store builder too.
+ *
+ * ```js
+ * import { useStore } from 'nanostores/react'
+ *
+ * import { router } from '../store/router'
+ *
+ * export const Layout = () => {
+ *   let page = useStore(router)
+ *   if (page.route === 'home') {
+ *     return <HomePage />
+ *   } else {
+ *     return <Error404 />
+ *   }
+ * }
+ * ```
+ *
+ * @param store Store instance.
+ * @returns Store value.
+ */
+declare function useStore<SomeStore extends Store>(store: SomeStore, options?: UseStoreOptions<SomeStore>): StoreValue<SomeStore>; //#endregion
 //#region src/internal.d.ts
 interface LikeC4VitePluginRpcOptions {
   /**