@lingxia/types 0.9.0 → 0.11.1

package/src/index.ts

@@ -4,276 +4,36 @@
  * Type declarations for the LingXia JS API, driven by Rust implementation.
  */
 
-export * from './app';
-export * from './lxapp';
-export * from './device';
-export * from './display';
-export * from './input';
-export * from './env';
-export * from './storage';
-export * from './file';
-export * from './transfer';
-export * from './location';
-export * from './navigator';
-export * from './system';
-export * from './update';
-export * from './media';
-export * from './share';
-export * from './ui';
+export * from './generated/logic';
+export * from './automation';
 export * from './error';
 export * from './generated/error';
 export * from './generated/i18n';
 
+import './generated/logic';
+
 import type {
   AppConfig,
   AppInstance,
-  HostAppApi,
-  PageMessagePort,
   PageConfig,
   PageInstance,
-  Surface,
-} from './app';
-
-import type {
-  LxAppInfo,
-} from './lxapp';
-
-import type {
-  DeviceInfo,
-  ScreenInfo,
-  MakePhoneCallOptions,
-  WifiInfo,
-  ConnectWifiOptions,
-  WifiConnectedCallback,
-  NetworkInfo,
-  NetworkChangeCallback,
-} from './device';
-
-import type { KeyEventCallback } from './input';
-
-import type { LxEnv } from './env';
-
-import type { Storage } from './storage';
-
-import type {
-  OpenFileOptions,
-  ChooseDirectoryOptions,
-  ChooseDirectoryResult,
-  ChooseFileOptions,
-  ChooseFileResult,
-  FileManager,
-} from './file';
-
-import type {
-  DownloadOptions,
-  DownloadTask,
-  UploadOptions,
-  UploadTask,
-} from './transfer';
-
-import type {
-  DeviceOrientation,
-  DeviceOrientationChangeEvent,
-} from './display';
-
-import type {
-  GetLocationOptions,
-  LocationInfo,
-} from './location';
-
-import type {
-  SystemSettingInfo,
-  OpenURLOptions,
-} from './system';
-
-import type { NavigateToLxAppOptions } from './navigator';
-
-import type { UpdateManager } from './update';
-
-import type {
-  GetImageInfoOptions,
-  ImageInfo,
-  CompressImageOptions,
-  CompressImageResult,
-  CompressVideoOptions,
-  CompressVideoResult,
-  GetVideoInfoOptions,
-  VideoInfo,
-  ExtractVideoThumbnailOptions,
-  ExtractVideoThumbnailResult,
-  ChooseMediaOptions,
-  ChosenMediaEntry,
-  PreviewMediaHandle,
-  PreviewMediaOptions,
-  SaveMediaOptions,
-  ScanCodeOptions,
-  ScanCodeResult,
-  VideoContext,
-} from './media';
-
-import type {
-  ShareOptions,
-  ShareResult,
-} from './share';
-
-import type {
-  ShowToastOptions,
-  ShowModalOptions,
-  ModalResult,
-  ShowActionSheetOptions,
-  ActionSheetResult,
-  NavigateToOptions,
-  NavigateBackOptions,
-  RedirectToOptions,
-  SwitchTabOptions,
-  ReLaunchOptions,
-  SetNavigationBarTitleOptions,
-  SetNavigationBarColorOptions,
-  TabBarRedDotOptions,
-  SetTabBarBadgeOptions,
-  RemoveTabBarBadgeOptions,
-  SetTabBarStyleOptions,
-  SetTabBarItemOptions,
-  SurfaceOpenOptions,
-  CapsuleRect,
-} from './ui';
-
-export interface SurfaceApi {
-  /**
-   * Dynamically opens a page or URL in a runtime-managed surface.
-   *
-   * `overlay` is cross-platform. `window` is a desktop capability and rejects
-   * on mobile platforms.
-   */
-  open(options: SurfaceOpenOptions): Promise<Surface>;
-}
+} from './generated/logic';
+import type { Automation } from './automation';
 
-export interface Lx {
-  env: LxEnv;
-  app: HostAppApi;
-  surface: SurfaceApi;
-
-  getDeviceInfo(): DeviceInfo;
-  getScreenInfo(): ScreenInfo;
-  vibrateShort(): boolean;
-  vibrateLong(): boolean;
-  makePhoneCall(options: MakePhoneCallOptions): boolean;
-
-  startWifi(): Promise<void>;
-  stopWifi(): Promise<void>;
-  connectWifi(options: ConnectWifiOptions): Promise<void>;
-  getWifiList(): Promise<WifiInfo[]>;
-  getConnectedWifi(): Promise<WifiInfo>;
-  onWifiConnected(callback: WifiConnectedCallback): void;
-  offWifiConnected(callback?: WifiConnectedCallback): void;
-  getNetworkInfo(): Promise<NetworkInfo>;
-  onNetworkChange(callback: NetworkChangeCallback): void;
-  offNetworkChange(callback?: NetworkChangeCallback): void;
-
-  setDeviceOrientation(orientation: DeviceOrientation): boolean;
-  onDeviceOrientationChange(callback: (event: DeviceOrientationChangeEvent) => void): void;
-  offDeviceOrientationChange(callback?: (event: DeviceOrientationChangeEvent) => void): void;
-
-  /**
-   * Open a local file with the requested strategy.
-   * Use `mode: 'review'` when the UX requires in-app preview,
-   * otherwise prefer `mode: 'auto'`.
-   */
-  openFile(options: OpenFileOptions): void;
-  downloadFile(options: DownloadOptions): DownloadTask;
-  uploadFile(options: UploadOptions): UploadTask;
-  getFileManager(): FileManager;
-
-  getStorage(): Storage;
-
-  getLocation(options?: GetLocationOptions): Promise<LocationInfo>;
-
-  navigateToLxApp(options: NavigateToLxAppOptions): Promise<void>;
-  navigateBackLxApp(): Promise<void>;
-
-  getLxAppInfo(): LxAppInfo;
-  getSystemSetting(): SystemSettingInfo;
-  openURL(options: OpenURLOptions): void;
-
-  getUpdateManager(): UpdateManager;
-
-  getImageInfo(options: GetImageInfoOptions): Promise<ImageInfo>;
-  compressImage(options: CompressImageOptions): Promise<CompressImageResult>;
-  compressVideo(options: CompressVideoOptions): Promise<CompressVideoResult>;
-  getVideoInfo(options: GetVideoInfoOptions): Promise<VideoInfo>;
-  extractVideoThumbnail(options: ExtractVideoThumbnailOptions): Promise<ExtractVideoThumbnailResult>;
-
-  chooseMedia(options?: ChooseMediaOptions): Promise<ChosenMediaEntry[]>;
-
-  /**
-   * Opens native media preview.
-   *
-   * Supports:
-   * - a single source path string for the simplest case
-   * - a single-item object for per-item options like `rotate`, `objectFit`, or `durationMs`
-   * - a sequence object for multi-item preview with `sources`, `startIndex`, and `advance`
-   *
-   * Returns a {@link PreviewMediaHandle} synchronously. Await `handle.completed`
-   * for the final session result (`reason`, `lastIndex`). Subscribe to
-   * `handle.presented` to learn when the first pixel hits the screen — useful
-   * for coordinating a hide of any overlay surface that was previously visible.
-   *
-   * `handle.completed` rejects with a cancellation error if `signal` is aborted;
-   * abort also requests the active native preview session to close immediately.
-   * `handle.presented` never rejects.
-   */
-  previewMedia(options: PreviewMediaOptions): PreviewMediaHandle;
-
-  saveImageToPhotosAlbum(options: SaveMediaOptions): Promise<void>;
-  saveVideoToPhotosAlbum(options: SaveMediaOptions): Promise<void>;
-
-  scanCode(options?: ScanCodeOptions): Promise<ScanCodeResult>;
-
-  share(options: ShareOptions): Promise<ShareResult>;
-
-  createVideoContext(componentId: string): VideoContext;
-
-  showToast(options: ShowToastOptions): void;
-  hideToast(): void;
-
-  showModal(options: ShowModalOptions): Promise<ModalResult>;
-
-  showActionSheet(options: ShowActionSheetOptions): Promise<ActionSheetResult>;
-
-  navigateTo(options: NavigateToOptions): Promise<PageMessagePort>;
-  navigateBack(options: NavigateBackOptions): void;
-  redirectTo(options: RedirectToOptions): Promise<void>;
-  switchTab(options: SwitchTabOptions): Promise<void>;
-  reLaunch(options: ReLaunchOptions): Promise<void>;
-
-  setNavigationBarTitle(options: SetNavigationBarTitleOptions): boolean;
-  setNavigationBarColor(options: SetNavigationBarColorOptions): boolean;
-  hideHomeButton(): boolean;
-
-  showTabBarRedDot(options: TabBarRedDotOptions): boolean;
-  hideTabBarRedDot(options: TabBarRedDotOptions): boolean;
-  setTabBarBadge(options: SetTabBarBadgeOptions): boolean;
-  removeTabBarBadge(options: RemoveTabBarBadgeOptions): boolean;
-  showTabBar(): boolean;
-  hideTabBar(): boolean;
-  setTabBarStyle(options: SetTabBarStyleOptions): boolean;
-  setTabBarItem(options: SetTabBarItemOptions): boolean;
-
-  startPullDownRefresh(): void;
-  stopPullDownRefresh(): void;
-
-  getCapsuleRect(): Promise<CapsuleRect>;
-
-  chooseFile(options?: ChooseFileOptions): Promise<ChooseFileResult>;
-  chooseDirectory(options?: ChooseDirectoryOptions): Promise<ChooseDirectoryResult>;
-
-  onKeyDown(callback: KeyEventCallback): void;
-  offKeyDown(callback?: KeyEventCallback): void;
-  onKeyUp(callback: KeyEventCallback): void;
-  offKeyUp(callback?: KeyEventCallback): void;
-}
+export type Lx = globalThis.Lx;
 
 declare global {
+  interface Lx {
+    /**
+     * In-process UI/runtime automation.
+     *
+     * Select the current app with `.lxapp()` or a specific running app with
+     * `.lxapp(appid)`. Host-only surfaces enforce the `host` privilege when
+     * selected; `lingxia dev` and the Runner grant it implicitly.
+     */
+    automation(): Automation;
+  }
+
   const lx: Lx;
 
   function App(config: AppConfig): AppInstance;

package/src/logic-globals.d.ts

@@ -0,0 +1 @@
+/// <reference path="./generated/logic-web.d.ts" />

package/src/process.ts

@@ -0,0 +1,135 @@
+/**
+ * OS process capability for trusted LingXia home lxapps.
+ *
+ * Add `@lingxia/types/process` to the Logic tsconfig only when the host sets
+ * `capabilities.process: true` and the home lxapp declares the `process`
+ * security privilege. These declarations have no runtime payload.
+ */
+
+export type RongSpawnStdio = "pipe" | "ignore" | "inherit";
+export type RongEnvMap = Record<string, string | undefined>;
+
+export interface RongSpawnOptions {
+  cwd?: string;
+  env?: RongEnvMap;
+  shell?: boolean;
+  stdin?: "pipe" | string | ArrayBuffer | ArrayBufferView | null;
+  stdout?: RongSpawnStdio;
+  stderr?: RongSpawnStdio;
+  timeout?: number;
+  killSignal?: string | number;
+  signal?: AbortSignal;
+  onExit?(
+    subprocess: RongSubprocess,
+    exitCode: number | null,
+    signalCode: number | null,
+    error?: unknown,
+  ): void | Promise<void>;
+}
+
+export interface RongSpawnOptionsWithCmd extends RongSpawnOptions {
+  cmd: string[];
+}
+
+export interface RongSyncSubprocess {
+  readonly exitCode: number | null;
+  readonly success: boolean;
+  readonly signalCode: number | null;
+  readonly stdout: Uint8Array;
+  readonly stderr: Uint8Array;
+}
+
+export interface RongReadableProcessStream extends ReadableStream<Uint8Array> {
+  bytes(): Promise<Uint8Array>;
+  text(): Promise<string>;
+  json(): Promise<unknown>;
+  blob(): Promise<Blob>;
+  lines(): AsyncIterableIterator<string>;
+}
+
+export interface RongOutputHandle {
+  write(chunk: string | ArrayBuffer | ArrayBufferView): void;
+  flush(): void;
+}
+
+export interface RongWritableProcessStream extends WritableStream<Uint8Array> {
+  write(chunk: string | ArrayBuffer | ArrayBufferView): Promise<this>;
+  flush(): Promise<void>;
+  end(): Promise<void>;
+}
+
+export interface RongSubprocess {
+  readonly pid: number | null;
+  readonly exitCode: number | null;
+  readonly signalCode: number | null;
+  readonly killed: boolean;
+  readonly success: boolean;
+  readonly exited: Promise<number | null>;
+  stdin: RongWritableProcessStream | null;
+  stdout: RongReadableProcessStream | null;
+  stderr: RongReadableProcessStream | null;
+  kill(signal?: string | number): boolean;
+  wait(): Promise<number | null>;
+  unref(): void;
+}
+
+export interface RongShellResult {
+  stdout: Uint8Array;
+  stderr: Uint8Array;
+  exitCode: number | null;
+  success: boolean;
+}
+
+export interface RongShellCommand extends PromiseLike<RongShellResult> {
+  cwd(path: string): RongShellCommand;
+  env(values: RongEnvMap): RongShellCommand;
+  quiet(): RongShellCommand;
+  nothrow(): RongShellCommand;
+  throws(value?: boolean): RongShellCommand;
+  run(): Promise<RongShellResult>;
+  text(): Promise<string>;
+  json(): Promise<unknown>;
+  blob(): Promise<Blob>;
+  lines(): AsyncIterableIterator<string>;
+}
+
+export interface RongShellTag {
+  (strings: TemplateStringsArray, ...values: unknown[]): RongShellCommand;
+  (command: string): RongShellCommand;
+  cwd(path?: string): string | RongShellTag | undefined;
+  env(values?: RongEnvMap): RongEnvMap | RongShellTag | undefined;
+  throws(value?: boolean): RongShellTag;
+  nothrow(): RongShellTag;
+  quiet(): RongShellTag;
+  escape(value: unknown): string;
+}
+
+export interface RongShellError extends Error {
+  command: string;
+  exitCode: number | null;
+  stdout: Uint8Array;
+  stderr: Uint8Array;
+}
+
+declare global {
+  /** Process APIs exposed only by a host with `capabilities.process`. */
+  interface RongNamespace {
+    readonly argv: string[];
+    readonly args: string[];
+    readonly env: RongEnvMap;
+    readonly stdin: RongReadableProcessStream;
+    readonly stdout: RongOutputHandle;
+    readonly stderr: RongOutputHandle;
+    spawn(cmd: string[], options?: RongSpawnOptions): RongSubprocess;
+    spawn(options: RongSpawnOptionsWithCmd): RongSubprocess;
+    spawnSync(cmd: string[], options?: RongSpawnOptions): RongSyncSubprocess;
+    spawnSync(options: RongSpawnOptionsWithCmd): RongSyncSubprocess;
+    readonly $: RongShellTag;
+    readonly ShellError: {
+      new (message: string): RongShellError;
+      prototype: RongShellError;
+    };
+  }
+
+  const Rong: RongNamespace;
+}

package/dist/app/index.d.ts

@@ -1,278 +0,0 @@
-/**
- * Host app, app lifecycle, and page instance APIs.
- */
-export interface AppBaseInfo {
-    language: string;
-    productName: string;
-    version: string;
-    SDKVersion: string;
-}
-export interface HostAppUpdateInfo {
-    version: string;
-    size?: number;
-    releaseNotes?: string[];
-    isForceUpdate: boolean;
-    /**
-     * Download and apply this checked update.
-     *
-     * `apply()` is single-use for this update object.
-     *
-     * The returned task can be awaited directly when progress is not needed, or
-     * consumed with `for await...of` to render progress.
-     *
-     * Direct package handoff is currently supported on Android and macOS. Other
-     * platforms reject with an unsupported-operation error; use `version` and
-     * `releaseNotes` to guide users to the appropriate app marketplace.
-     */
-    apply(): HostAppUpdateTask;
-}
-export type HostAppUpdateApplyStage = 'download' | 'install';
-export type HostAppUpdateCheckResult = {
-    hasUpdate: false;
-    update?: never;
-} | {
-    hasUpdate: true;
-    update: HostAppUpdateInfo;
-};
-export type HostAppUpdateEvent = {
-    state: 'downloading';
-    downloadedBytes?: number;
-    progress?: number;
-} | {
-    state: 'downloaded' | 'installRequested';
-} | {
-    state: 'failed';
-    stage: HostAppUpdateApplyStage;
-    error: string;
-};
-export interface HostAppUpdateResult {
-    state: 'installRequested';
-}
-export interface HostAppUpdateIteratorResult {
-    done: boolean;
-    value?: HostAppUpdateEvent;
-}
-export interface HostAppUpdateTask extends PromiseLike<HostAppUpdateResult>, AsyncIterable<HostAppUpdateEvent> {
-    next(): Promise<HostAppUpdateIteratorResult>;
-    /** Stops iteration only. It does not cancel an app update already handed to the platform. */
-    return(): Promise<HostAppUpdateIteratorResult>;
-    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<HostAppUpdateResult | TResult>;
-    finally(onfinally?: (() => void) | null): Promise<HostAppUpdateResult>;
-    wait(): Promise<HostAppUpdateResult>;
-}
-/**
- * Build-time environment version of the host app.
- *
- * Surfaced via {@link HostAppApi.envVersion}. Mirrors the
- * `crates/lingxia-update::ReleaseType` enum and the `envVersion` field in the
- * generated `app.json`. Pre-envVersion app artifacts are treated as `'release'`.
- *
- * Note: this is *separate* from `LxAppEnvVersion` in the navigator module,
- * which encodes lxapp release channels (`'develop' | 'preview' | 'release'`)
- * for cross-app navigation URLs and uses the truncated `develop` form.
- */
-export type HostAppEnvVersion = 'developer' | 'preview' | 'release';
-export interface HostAppApi {
-    /**
-     * The environment this build was produced for, mirroring `app.json::envVersion`.
-     * Always present; defaults to `'release'` for builds produced before the field
-     * existed in the artifact.
-     *
-     * Use this to branch on environment-specific behavior (e.g. verbose logging in
-     * developer builds, distinct theme tinting, distinct error-reporter tags).
-     * Synchronous; the value is fixed at app boot.
-     */
-    readonly envVersion: HostAppEnvVersion;
-    getBaseInfo(): AppBaseInfo;
-    /**
-     * Check whether the host app has an update.
-     *
-     * This is a host app level capability and is only available to the home
-     * lxapp. Non-home lxapps receive a permission error.
-     *
-     * Calling this API opts the host app into custom update handling for this
-     * process. LingXia will not show its built-in host app update UI or
-     * auto-install host app updates after that point.
-     *
-     * If no update is available, or if an update requires a newer LingXia
-     * runtime than the current host app provides, `hasUpdate` is `false`.
-     *
-     * `checkUpdate()` may return version metadata on platforms that cannot apply
-     * host app packages directly. In that case, `update.apply()` rejects with an
-     * unsupported-operation error.
-     */
-    checkUpdate(): Promise<HostAppUpdateCheckResult>;
-    /**
-     * Exit the host app immediately.
-     *
-     * This API does not show a confirmation dialog. If the user should confirm
-     * first, call `lx.showModal(...)` in page logic and invoke `lx.app.exit()`
-     * only after the user confirms.
-     */
-    exit(): void;
-}
-export interface AppLifecycleEventArgs {
-    source: 'host' | 'lxapp';
-    reason: 'foreground' | 'background' | 'screenshot' | 'open' | 'close' | 'switch_back' | 'switch_away';
-}
-export interface AppLaunchOptions {
-    path?: string;
-    query?: Record<string, string>;
-    scene?: number;
-    referrerInfo?: {
-        appId?: string;
-        extraData?: Record<string, unknown>;
-    };
-}
-export interface AppConfig {
-    globalData?: Record<string, unknown>;
-    onLaunch?: (options?: AppLaunchOptions) => void | Promise<void>;
-    onShow?: (args?: AppLifecycleEventArgs) => void | Promise<void>;
-    onHide?: (args?: AppLifecycleEventArgs) => void | Promise<void>;
-    onUserCaptureScreen?: () => void | Promise<void>;
-    [key: string]: unknown;
-}
-export interface AppInstance extends AppConfig {
-    globalData: Record<string, unknown>;
-}
-export interface PageLoadOptions {
-    [key: string]: string | undefined;
-}
-export interface PageConfig<TData extends Record<string, unknown> = Record<string, unknown>> {
-    data?: TData;
-    onLoad?: (options?: PageLoadOptions) => void | Promise<void>;
-    onShow?: () => void | Promise<void>;
-    onReady?: () => void | Promise<void>;
-    onHide?: () => void | Promise<void>;
-    onUnload?: () => void | Promise<void>;
-    onPullDownRefresh?: () => void | Promise<void>;
-    [key: string]: unknown;
-}
-export type SurfaceCloseReason = 'user' | 'programmatic' | 'owner_closed' | 'app_closed' | 'failed'
-/**
- * The SDK reclaimed a long-hidden overlay surface for resource reasons.
- * Treat as a normal close: the page instance is gone; further postMessage /
- * show / hide calls will fail. The opener may immediately reopen if needed.
- */
- | 'reclaimed' | 'unknown';
-export interface SurfaceClosedEvent {
-    id: string;
-    kind: 'overlay' | 'window';
-    reason: SurfaceCloseReason;
-}
-/**
- * Detail payload for `onShow` / `onHide` events. `source` identifies which
- * Surface object initiated the visibility change so observers can
- * distinguish self-driven transitions from peer-driven ones (e.g. an opener
- * UI that wants to update its own button state only when the page side
- * toggled visibility).
- */
-export interface SurfaceVisibilityEvent {
-    id: string;
-    kind: 'overlay' | 'window';
-    source: 'opener' | 'page';
-}
-export interface Surface {
-    readonly id: string;
-    readonly kind: 'overlay' | 'window';
-    /**
-     * Last-known visibility, kept in sync with the native side via show/hide
-     * events. False once the surface has been closed. Safe to bind into
-     * declarative UI; for event-driven updates subscribe via `onShow`/`onHide`.
-     */
-    readonly visible: boolean;
-    /**
-     * True until `close()` fires. After close the surface is detached and the
-     * page instance is being torn down; further `show()` / `hide()` calls will
-     * reject.
-     */
-    readonly alive: boolean;
-    /**
-     * Sends a message to the other side of a page surface.
-     *
-     * For the opener this targets the opened page. For the opened page this
-     * targets the opener. URL surfaces have no page-side receiver.
-    */
-    postMessage(message: unknown): void;
-    onMessage(handler: (message: unknown) => void): () => void;
-    onClose(handler: (event: SurfaceClosedEvent) => void): () => void;
-    /**
-     * Fires when the surface transitions to visible, regardless of whether
-     * `show()` was called on this side or on the peer. Returns an unsubscribe
-     * function. Only fires on real state changes — calling `show()` on an
-     * already-visible surface is a no-op for listeners.
-     */
-    onShow(handler: (event: SurfaceVisibilityEvent) => void): () => void;
-    /**
-     * Fires when the surface transitions to hidden, regardless of which side
-     * triggered it. Returns an unsubscribe function. Only fires on real state
-     * changes.
-     */
-    onHide(handler: (event: SurfaceVisibilityEvent) => void): () => void;
-    close(): Promise<void>;
-    /**
-     * Toggle the surface to visible without tearing it down. The page instance
-     * and its state survive a hide / show round-trip — only close() actually
-     * destroys the surface and fires the onClose listener. Idempotent: calling
-     * on an already-visible surface resolves without firing `onShow`.
-     */
-    show(): Promise<void>;
-    /**
-     * Hide the surface without destroying it. The page instance stays mounted,
-     * so a subsequent show() restores the same scroll position, form input,
-     * and JS state. Hidden surfaces still receive postMessage but are not
-     * visible to the user. Idempotent.
-     */
-    hide(): Promise<void>;
-}
-export interface PageMessagePort {
-    postMessage(message: unknown): void;
-    onMessage(handler: (message: unknown) => void): () => void;
-}
-export interface PageInstance<TData extends Record<string, unknown> = Record<string, unknown>> {
-    data: TData;
-    route: string;
-    /**
-     * Available when this page was opened by `lx.surface.open(...)`.
-     */
-    surface?: Surface;
-    /**
-     * Available when this page was opened by `lx.navigateTo(...)`.
-     */
-    opener?: PageMessagePort;
-    setData(data: Partial<TData> | Record<string, unknown>, callback?: () => void): void;
-}
-/**
- * Injected by the runtime into methods listed in `stream_handlers` page metadata.
- *
- * Use this when your async source uses callbacks rather than an async iterator.
- * For the generator form (`async *method()`), no handle is needed — the runtime
- * pumps the generator automatically.
- */
-export interface StreamHandle<T = unknown> {
-    /** Send a chunk to View. */
-    send(payload: T): void;
-    /** End the stream with an optional final value. */
-    end(result?: unknown): void;
-    /** End the stream with an error. */
-    error(code: string, message?: string): void;
-}
-/**
- * Injected by the runtime as the second parameter when View opens a channel.
- *
- * Use `ch.send()` to push data to View, `ch.on()` to receive data/close
- * events from View, and `ch.close()` to shut down the channel.
- */
-export interface ChannelHandle<TSend = unknown, TReceive = unknown> {
-    /** Push a message to View. */
-    send(payload: TSend): void;
-    /** Close the channel from Logic side. */
-    close(code?: string, reason?: string): void;
-    /** Register a listener for incoming events. */
-    on(event: 'data', handler: (payload: TReceive) => void): void;
-    on(event: 'close', handler: (info: {
-        code: string;
-        reason: string;
-    }) => void): void;
-}
-//# sourceMappingURL=index.d.ts.map