@qilin-agent/client-shortcuts 0.0.0-stage → 3.1.4

package/lib/types/client/native.d.ts

@@ -0,0 +1,13 @@
+import type { DesktopKeyboardApi, ShortcutConfigSnapshot } from '../protocol.ts';
+import type { ShortcutRegistry } from './registry.ts';
+/**
+ * Route native menu, main-frame, and embedded-frame input through the shared command registry.
+ * @param window - trusted product document.
+ * @param keyboard - top-frame preload capability.
+ * @param registry - window-local command owner.
+ * @param snapshot - latest accepted configuration.
+ * @param reset - clears pending fixed sequences when native input bypasses DOM delivery.
+ * @returns disposer releasing native input.
+ */
+export declare function installNativeKeyboard(window: Window, keyboard: DesktopKeyboardApi, registry: ShortcutRegistry, snapshot: () => ShortcutConfigSnapshot, reset?: () => void): () => void;
+//# sourceMappingURL=native.d.ts.map

package/lib/types/client/registry.d.ts

@@ -0,0 +1,80 @@
+import type { ShortcutCommandId, ShortcutConfigSnapshot, ShortcutDefinition, ShortcutPlatform, ShortcutRuntime } from '../protocol.ts';
+import type { ShortcutCatalogEntry, ShortcutCommand, ShortcutContext, ShortcutGesture, ShortcutFixedCommand, ShortcutFixedCatalogEntry } from './types.ts';
+/** Dispatch consumption is independent of later business-operation success. */
+type ShortcutDispatch = {
+    status: 'handled';
+    commandId: ShortcutCommandId;
+} | {
+    status: 'blocked';
+    commandId: ShortcutCommandId;
+    reason: string;
+} | {
+    status: 'pass';
+};
+/** Application command registry; adapters own event listeners, feature plugins own actions. */
+export declare class ShortcutRegistry {
+    readonly runtime: ShortcutRuntime;
+    readonly platform: ShortcutPlatform;
+    private readonly commands;
+    private readonly fixedCommands;
+    private readonly conflicts;
+    private readonly bindings;
+    private readonly state;
+    /** Effective localized rows derived from the accepted configuration. */
+    readonly catalog: {
+        getSnapshot: () => readonly ShortcutCatalogEntry[];
+        subscribe: (listener: () => void) => () => void;
+    };
+    /** Accepted preferences and visible read diagnostics. */
+    readonly config: {
+        getSnapshot: () => ShortcutConfigSnapshot;
+        subscribe: (listener: () => void) => () => void;
+    };
+    /** Fixed local operations whose owning plugins are mounted. */
+    readonly fixedCatalog: import("@qilin-agent/client-store").SnapshotStore<readonly ShortcutFixedCatalogEntry[]>;
+    constructor(runtime: ShortcutRuntime, platform: ShortcutPlatform, config?: ShortcutConfigSnapshot);
+    /**
+     * Return the serializable active catalog for storage validation.
+     * @returns definitions without callbacks or localized labels.
+     */
+    definitions(): readonly ShortcutDefinition[];
+    /**
+     * Register a read-only input action whose keys cannot be assigned to editable commands.
+     * @param command - owner-localized action and readable sequence.
+     * @returns idempotent disposer removing its reference row.
+     */
+    registerFixed(command: ShortcutFixedCommand): () => void;
+    private refreshFixedLabels;
+    /**
+     * Publish accepted preferences and all derived labels atomically.
+     * @param config - storage owner's latest accepted snapshot.
+     */
+    configure(config: ShortcutConfigSnapshot): void;
+    /**
+     * Register atomically after checking defaults for all supported platforms and shells.
+     * @param command - feature-owned command definition.
+     * @returns idempotent disposer removing both matching and catalog entries.
+     */
+    register(command: ShortcutCommand): () => void;
+    /**
+     * Recompute effective bindings when preferences, commands, or locale change.
+     * @param config - accepted configuration, defaulting to the current snapshot.
+     */
+    refreshLabels(config?: ShortcutConfigSnapshot): void;
+    /**
+     * Invoke a native menu selection independently of its optional key binding.
+     * @param id - registered product command.
+     * @param context - live input owner and modal state.
+     */
+    invoke(id: ShortcutCommandId, context: ShortcutContext): void;
+    /**
+     * Windows/macOS Desktop bindings override local regions and modal controls independently of their configuration source.
+     * @param gesture - normalized DOM/native input facts.
+     * @param context - synchronous input and modal owner.
+     * @param consume - adapter's preventDefault, called before business execution.
+     * @returns handled, blocked with a reason, or pass for local/system input.
+     */
+    dispatch(gesture: ShortcutGesture, context: ShortcutContext, consume: () => void): ShortcutDispatch;
+}
+export {};
+//# sourceMappingURL=registry.d.ts.map

package/lib/types/client/storage.d.ts

@@ -0,0 +1,20 @@
+import type { DesktopShortcutsApi, ShortcutConfigSnapshot, ShortcutPlatform } from '../protocol.ts';
+/** Browser-profile and origin-local preference key. */
+export declare const SHORTCUT_STORAGE_KEY = "qilin.keybindings.v1";
+/**
+ * Connect localStorage and same-origin external updates to the shared transaction coordinator.
+ * @param window - owning browser window.
+ * @param platform - visiting device platform.
+ * @param publish - accepts complete configuration snapshots.
+ * @returns adapter and lifecycle disposal.
+ */
+export declare function webShortcutStorage(window: Window, platform: ShortcutPlatform, publish: (snapshot: ShortcutConfigSnapshot) => void): DesktopShortcutsApi & {
+    dispose(): void;
+};
+/**
+ * Read the origin-scoped preload capability; a missing bridge is an explicit configuration failure.
+ * @param window - product window.
+ * @returns the restricted Desktop API, or undefined while the preload is unavailable.
+ */
+export declare function desktopShortcutStorage(window: Window): DesktopShortcutsApi | undefined;
+//# sourceMappingURL=storage.d.ts.map

package/lib/types/client/types.d.ts

@@ -0,0 +1,146 @@
+/** Command contributions and immutable catalog values. */
+import type { ObservableSnapshot } from '@qilin-agent/client-store';
+import type { BindingIssue, NormalizedBinding, ShortcutConfigSnapshot, ShortcutEdit, ShortcutRevision, ShortcutSaveResult, ShortcutBinding, ShortcutCommandId, ShortcutPlatform, ShortcutProfile, ShortcutRuntime } from '../protocol.ts';
+/** Local input owner resolved before an application command. */
+export type ShortcutRegion = 'page' | 'editable' | 'terminal';
+/** Synchronous DOM context; owners capture business targets in resolve(). */
+export interface ShortcutContext {
+    readonly source?: 'keyboard' | 'menu' | 'iframe' | 'webview';
+    readonly region: ShortcutRegion;
+    readonly modal: string | null;
+    /** Original input element, or null when no document target is available. */
+    readonly target: Element | null;
+}
+/** A resolved action captures its target; failures remain the owner's responsibility. */
+export type ShortcutResolution = {
+    status: 'handled';
+    run(): void;
+} | {
+    status: 'blocked';
+    reason: string;
+} | {
+    status: 'pass';
+};
+/** One command's labels, defaults, input ownership, and target resolver. */
+export interface ShortcutCommand {
+    readonly id: ShortcutCommandId;
+    readonly label: () => string;
+    readonly aliases: readonly string[];
+    readonly defaults: Readonly<Partial<Record<ShortcutProfile, ShortcutBinding>>>;
+    readonly regions: readonly ShortcutRegion[];
+    /**
+     * Allowed modal identifiers for Web/Linux keyboard input and explicit menu actions;
+     * Windows/macOS Desktop keyboard bindings take priority.
+     */
+    readonly modals: readonly string[];
+    resolve(context: ShortcutContext): ShortcutResolution;
+}
+/** JSON-compatible catalog row, shared by reference, tooltips, and controls. */
+export interface ShortcutCatalogEntry {
+    readonly id: ShortcutCommandId;
+    readonly label: string;
+    readonly aliases: readonly string[];
+    readonly keys: readonly string[];
+    readonly aria: string | undefined;
+    readonly binding: NormalizedBinding | null;
+    readonly modified: boolean;
+    readonly conflicts: readonly ShortcutCommandId[];
+    readonly issue: BindingIssue | null;
+}
+/** Keyboard adapter input, with composition and local consumption already resolved. */
+export interface ShortcutGesture {
+    readonly code: string;
+    /** Second physical key currently held with code; matching ignores pair order. */
+    readonly secondCode?: string;
+    readonly control: boolean;
+    readonly alt: boolean;
+    readonly shift: boolean;
+    readonly meta: boolean;
+    readonly repeat: boolean;
+    readonly composing: boolean;
+    readonly defaultPrevented: boolean;
+}
+/** Local fixed input delivered after controls, or a sequence-invalidating interaction. */
+export type ShortcutFixedInput = {
+    readonly type: 'keydown';
+    readonly gesture: ShortcutGesture;
+    readonly context: ShortcutContext;
+    consume(): void;
+} | {
+    readonly type: 'reset';
+};
+/** Read-only input action contributed while its owning feature is mounted. */
+export interface ShortcutFixedCommand {
+    readonly id: ShortcutCommandId;
+    readonly label: () => string;
+    readonly keys: readonly string[];
+    /** One or more physical combinations reserved by this action, including individual steps of a sequence. */
+    readonly bindings: readonly [ShortcutBinding, ...ShortcutBinding[]];
+    readonly group: 'application' | 'input' | 'menus' | 'approval';
+}
+/** Localized fixed-action row; its key sequence is not an editable binding. */
+export interface ShortcutFixedCatalogEntry {
+    readonly id: ShortcutCommandId;
+    readonly label: string;
+    readonly keys: readonly string[];
+    readonly bindings: readonly NormalizedBinding[];
+    readonly group: ShortcutFixedCommand['group'];
+}
+/** Feature-facing keyboard registry. */
+export interface Shortcuts {
+    readonly runtime: ShortcutRuntime;
+    readonly platform: ShortcutPlatform;
+    readonly catalog: ObservableSnapshot<readonly ShortcutCatalogEntry[]>;
+    readonly config: ObservableSnapshot<ShortcutConfigSnapshot>;
+    readonly fixedCatalog: ObservableSnapshot<readonly ShortcutFixedCatalogEntry[]>;
+    readonly stopSequenceMs: number;
+    /**
+     * Contribute one fixed action and reserve its keys against editable bindings.
+     * @param command - owner-localized name, group, readable keys, and reserved physical combinations.
+     * @returns idempotent disposer removing the fixed row.
+     */
+    registerFixed(command: ShortcutFixedCommand): () => void;
+    /**
+     * Observe locally arbitrated input and interaction resets for fixed sequences.
+     * @param listener - owner handler; composing or consumed input must not trigger actions.
+     * @returns disposer releasing the handler.
+     */
+    observeFixedInput(listener: (input: ShortcutFixedInput) => void): () => void;
+    /**
+     * Describe a candidate using the device's physical-key and reservation rules; invalid codes throw.
+     * @param binding - candidate combination, or null for an unbound command.
+     * @returns canonical binding, visible keys, rejection reason, and overlapping editable/fixed command IDs.
+     */
+    describeBinding(binding: ShortcutBinding | null): {
+        binding: NormalizedBinding | null;
+        keys: readonly string[];
+        issue: BindingIssue | null;
+        conflicts: readonly ShortcutCommandId[];
+    };
+    /**
+     * Save a reviewed edit; failures preserve both accepted preferences and the caller's draft.
+     * @param edit - set, clear, reset, or reset-all operation.
+     * @param revision - accepted revision reviewed by the user.
+     * @returns persistence outcome and current accepted configuration.
+     * @throws when publishing the accepted command catalog fails.
+     */
+    edit(edit: ShortcutEdit, revision: ShortcutRevision): Promise<ShortcutSaveResult>;
+    /**
+     * Suppress native menu accelerators while the recording layer owns keyboard input; reject if Desktop cannot acknowledge it.
+     * @param active - whether the recording layer is mounted.
+     * @returns completion of the native interception update.
+     */
+    recording(active: boolean): Promise<void>;
+    /**
+     * Request closure of the Desktop window using the currently accepted shortcut revision.
+     * @returns completion of the native request; rejects outside Desktop or when the bridge request fails.
+     */
+    closeWindow(): Promise<void>;
+    /**
+     * Register a command; duplicate ids and overlapping default bindings throw.
+     * @param command - feature-owned labels, defaults, and target resolver.
+     * @returns disposer removing the binding and catalog entry.
+     */
+    register(command: ShortcutCommand): () => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/config.d.ts

@@ -0,0 +1,10 @@
+/** Window-local timing accepted by the Host and browser keyboard service. */
+import z from '@qilin-agent/schemastery';
+/** Fixed shortcut sequence settings. */
+export interface Config {
+    /** Maximum interval between independent Escape presses for stopping a reply, in milliseconds. */
+    stopSequenceMs: number;
+}
+/** Validated deployment settings for fixed keyboard sequences. */
+export declare const Config: z<Partial<Config>, Config>;
+//# sourceMappingURL=config.d.ts.map

package/lib/types/configuration.d.ts

@@ -0,0 +1,100 @@
+import type { NormalizedBinding, ShortcutBinding, ShortcutCommandId, ShortcutPlatform, ShortcutProfile, ShortcutRuntime } from './binding.ts';
+/** Overrides are platform-local; absent commands inherit defaults and null explicitly unbinds. */
+export interface ShortcutDocument {
+    readonly schemaVersion: 1 | 2;
+    readonly profiles: Readonly<Partial<Record<ShortcutProfile, Readonly<Record<string, ShortcutBinding | null>>>>>;
+}
+/** Serializable command definitions accepted from the trusted product frame. */
+export interface ShortcutDefinition {
+    readonly id: ShortcutCommandId;
+    readonly defaults: Readonly<Partial<Record<ShortcutProfile, ShortcutBinding>>>;
+    /** Fixed actions reserve one or more combinations instead of exposing an editable default. */
+    readonly fixed?: readonly [ShortcutBinding, ...ShortcutBinding[]];
+}
+/** Validation failures select localized copy in the UI. */
+export type BindingIssue = 'reserved' | 'unsupported-browser' | 'modifier-required' | 'unsupported-key';
+/** A conflicting row keeps its requested binding visible but cannot execute it. */
+export interface EffectiveShortcut {
+    readonly id: ShortcutCommandId;
+    readonly binding: NormalizedBinding | null;
+    readonly modified: boolean;
+    readonly conflicts: readonly ShortcutCommandId[];
+    readonly issue: BindingIssue | null;
+}
+/** One revision-checked preference edit, limited to the current runtime and platform. */
+export type ShortcutEdit = {
+    type: 'set';
+    id: ShortcutCommandId;
+    binding: ShortcutBinding | null;
+} | {
+    type: 'reset';
+    id: ShortcutCommandId;
+} | {
+    type: 'reset-all';
+};
+/**
+ * Validate JSON binding fields before normalization; unknown fields are rejected to prevent lossy rewrites.
+ * @param value - file or IPC input.
+ * @returns a binding with a supported physical code, or null for explicit removal.
+ */
+export declare function parseBinding(value: unknown): ShortcutBinding | null;
+/**
+ * Decode the complete document while preserving dormant command overrides.
+ * @param raw - stored JSON, or null for a missing document.
+ * @returns the accepted document or a classified read failure.
+ */
+export declare function parseShortcutDocument(raw: string | null): ShortcutDocument | 'invalid' | 'future';
+/**
+ * Check system, editor, and browser reservations using expanded physical modifiers.
+ * @param binding - normalized candidate.
+ * @param runtime - receiving application shell.
+ * @param platform - receiving device.
+ * @returns the rejection reason, or null when this combination is allowed.
+ */
+export declare function bindingIssue(binding: NormalizedBinding, runtime: ShortcutRuntime, platform: ShortcutPlatform): BindingIssue | null;
+/**
+ * Select the command owner's explicit default for one device profile.
+ * @param definition - command identity and per-profile defaults.
+ * @param runtime - receiving shell.
+ * @param platform - receiving device.
+ * @returns the declared physical binding, or undefined for an unbound action.
+ */
+export declare function resolveShortcutDefault(definition: ShortcutDefinition, runtime: ShortcutRuntime, platform: ShortcutPlatform): ShortcutBinding | undefined;
+/**
+ * Resolve overrides and conflicts independently of registration order. Explicit overrides displace defaults.
+ * @param definitions - active commands.
+ * @param document - accepted preferences.
+ * @param runtime - receiving shell.
+ * @param platform - receiving device.
+ * @returns every active command, including unavailable conflicting bindings.
+ */
+export declare function effectiveShortcuts(definitions: readonly ShortcutDefinition[], document: ShortcutDocument, runtime: ShortcutRuntime, platform: ShortcutPlatform): readonly EffectiveShortcut[];
+/**
+ * Detect identical combinations or a single key contained in a two-key chord.
+ * @param left - normalized candidate.
+ * @param right - normalized occupied binding.
+ * @returns whether both bindings require the same modifiers and overlap.
+ */
+export declare function overlappingBindings(left: NormalizedBinding, right: NormalizedBinding): boolean;
+/**
+ * Apply an edit without modifying other profiles or dormant overrides.
+ * @param document - accepted document.
+ * @param edit - validated operation.
+ * @param runtime - current shell.
+ * @param platform - current device.
+ * @returns the candidate document, pending conflict checks and durable storage.
+ */
+export declare function editShortcutDocument(document: ShortcutDocument, edit: ShortcutEdit, runtime: ShortcutRuntime, platform: ShortcutPlatform): ShortcutDocument;
+/**
+ * Validate a preference edit at the Desktop IPC boundary.
+ * @param value - untrusted renderer request.
+ * @returns the constrained operation; malformed requests throw.
+ */
+export declare function parseShortcutEdit(value: unknown): ShortcutEdit;
+/**
+ * Validate the trusted product's serializable command catalog at IPC ingress.
+ * @param value - renderer-supplied active command definitions.
+ * @returns validated definitions; duplicate IDs, overlapping defaults, and unsupported combinations throw.
+ */
+export declare function parseShortcutDefinitions(value: unknown): readonly ShortcutDefinition[];
+//# sourceMappingURL=configuration.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,11 @@
+/** Host configuration for window-local keyboard sequences. */
+import type { Context } from '@qilin-agent/kylin';
+import type { Config } from './config.ts';
+export { Config } from './config.ts';
+/**
+ * Embed validated keyboard settings in product pages.
+ * @param ctx - Host context serving browser pages.
+ * @param config - sequence timing adopted when the page loads.
+ */
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/native.d.ts

@@ -0,0 +1,32 @@
+/** Trusted product-window input exchanged with Electron's top-frame preload. */
+import type { ShortcutRevision } from './persistence.ts';
+import type { ShortcutCommandId } from './binding.ts';
+/** Native input carries the accepted configuration identity; frame names identify the focused iframe or browser guest embedding element. */
+export type DesktopShortcutInput = {
+    readonly revision: ShortcutRevision;
+} & ({
+    readonly kind: 'menu';
+    readonly commandId: ShortcutCommandId;
+} | {
+    readonly kind: 'keyboard' | 'iframe' | 'webview';
+    readonly frameName: string;
+    readonly code: string;
+    readonly secondCode?: string;
+    readonly control: boolean;
+    readonly alt: boolean;
+    readonly shift: boolean;
+    readonly meta: boolean;
+    readonly repeat: boolean;
+});
+/** Window-scoped capabilities exposed only to the product main frame. */
+export interface DesktopKeyboardApi {
+    /** Subscribe to verified native input. @param listener - current document consumer. @returns listener disposer. */
+    subscribe(listener: (input: DesktopShortcutInput) => void): () => void;
+    /**
+     * Close the owning window if its configuration is still current.
+     * @param revision - accepted configuration identity.
+     * @returns IPC completion.
+     */
+    closeWindow(revision: ShortcutRevision): Promise<void>;
+}
+//# sourceMappingURL=native.d.ts.map

package/lib/types/persistence.d.ts

@@ -0,0 +1,76 @@
+import type { Branded } from '@qilin-agent/brand';
+import type { BindingIssue, ShortcutDefinition, ShortcutDocument, ShortcutEdit } from './configuration.ts';
+import type { ShortcutCommandId, ShortcutPlatform, ShortcutRuntime } from './binding.ts';
+/** Opaque accepted-state identity, invalidated by configuration and catalog changes. */
+export type ShortcutRevision = Branded<'ShortcutRevision'>;
+/** Read state retains the last accepted document on failure; loading does not enable commands. */
+export interface ShortcutConfigSnapshot {
+    readonly revision: ShortcutRevision;
+    /** Monotonic within one storage-owner lifetime; clients discard out-of-order IPC replies. */
+    readonly sequence: number;
+    readonly document: ShortcutDocument;
+    readonly status: 'loading' | 'ready' | 'unreadable';
+    readonly error: 'read' | 'invalid' | 'future' | null;
+    readonly usingDefaults: boolean;
+}
+/** Save failures never replace effective preferences. */
+export interface ShortcutSaveResult {
+    readonly status: 'saved' | 'stale' | 'unreadable' | 'write-failed' | 'not-ready' | 'conflict';
+    readonly snapshot: ShortcutConfigSnapshot;
+    readonly issue?: BindingIssue;
+    readonly conflicts?: readonly ShortcutCommandId[];
+}
+/** Storage adapter owns path/origin isolation and complete replacement on successful writes. */
+export interface ShortcutStorage {
+    read(): string | null | Promise<string | null>;
+    write(raw: string): void | Promise<void>;
+}
+/** Restricted Desktop preload API; file paths and accelerators never cross from Renderer. */
+export interface DesktopShortcutsApi {
+    get(definitions: readonly ShortcutDefinition[]): Promise<ShortcutConfigSnapshot>;
+    edit(edit: ShortcutEdit, revision: ShortcutRevision): Promise<ShortcutSaveResult>;
+    subscribe(listener: (snapshot: ShortcutConfigSnapshot) => void): () => void;
+    recording(active: boolean): Promise<void>;
+}
+/**
+ * Create a disabled initial snapshot for asynchronous adapter startup.
+ * @returns a fresh configuration with no accepted persisted state.
+ */
+export declare function initialShortcutConfig(): ShortcutConfigSnapshot;
+/** Single-writer coordinator shared by localStorage and Electron's atomic file adapter. */
+export declare class ShortcutPersistence {
+    private readonly storage;
+    private readonly runtime;
+    private readonly platform;
+    private readonly rereadBeforeWrite;
+    private readonly publish;
+    private snapshot;
+    private raw;
+    private queue;
+    private definitions;
+    private active;
+    constructor(storage: ShortcutStorage, runtime: ShortcutRuntime, platform: ShortcutPlatform, rereadBeforeWrite: boolean, publish: (snapshot: ShortcutConfigSnapshot) => void);
+    /**
+     * Install or revoke a product catalog and invalidate drafts from its previous lifetime.
+     * @param definitions - current trusted definitions, or null while the product is not ready.
+     */
+    setDefinitions(definitions: readonly ShortcutDefinition[] | null): void;
+    /** Stop accepting edits or publishing late completions. */
+    dispose(): void;
+    /**
+     * Read the current file; failures retain the last accepted document and disable ordinary writes.
+     * @returns the accepted snapshot or diagnostic snapshot.
+     */
+    readCurrent(): Promise<ShortcutConfigSnapshot>;
+    /**
+     * Compare the draft revision, validate the complete candidate, then persist before publishing.
+     * @param edit - constrained preference operation.
+     * @param revision - state against which the user reviewed the edit.
+     * @returns a classified outcome and the currently accepted snapshot.
+     */
+    edit(edit: ShortcutEdit, revision: ShortcutRevision): Promise<ShortcutSaveResult>;
+    private serialize;
+    private accept;
+    private read;
+}
+//# sourceMappingURL=persistence.d.ts.map

package/lib/types/protocol.d.ts

@@ -0,0 +1,6 @@
+/** Physical-key and versioned preference protocol shared by Client and Desktop main. */
+export * from './binding.ts';
+export * from './configuration.ts';
+export * from './persistence.ts';
+export * from './native.ts';
+//# sourceMappingURL=protocol.d.ts.map

package/package.json

@@ -1,6 +1,71 @@
 {
   "name": "@qilin-agent/client-shortcuts",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "description": "Application keyboard command registry and physical-key routing",
+  "version": "3.1.4",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kkutysllb/QiLin.git",
+    "directory": "packages/client/shortcuts"
+  },
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json",
+    "./protocol": {
+      "types": "./lib/types/protocol.d.ts",
+      "default": "./lib/protocol.js"
+    }
+  },
+  "files": [
+    "lib/index.js",
+    "lib/client.js",
+    "lib/protocol.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "qilin": {
+    "client": {
+      "inject": [
+        "@qilin-agent/client-locale"
+      ],
+      "platform": "web"
+    }
+  },
+  "peerDependencies": {
+    "@qilin-agent/kylin": "~4.0.3"
+  },
+  "devDependencies": {
+    "@qilin-agent/brand": "3.1.4",
+    "@qilin-agent/client-locale": "3.1.4",
+    "@qilin-agent/kylin": "~4.0.3",
+    "@qilin-agent/client-store": "3.1.4",
+    "@qilin-agent/host-webserver": "3.1.4",
+    "@qilin-agent/client-test-runtime": "3.1.4",
+    "@qilin-agent/client-ui-primitives": "3.1.4"
+  },
+  "dependencies": {
+    "@qilin-agent/schemastery": "~3.18.3",
+    "@qilin-agent/util-values": "3.1.4",
+    "@qilin-agent/util-crypto": "3.1.4"
+  },
+  "scripts": {
+    "bundle": "tsdown",
+    "watch": "tsdown --watch"
+  }
 }