cordisx 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/bundled-plugins/@cordisx/channel/dist/locales.d.ts

@@ -0,0 +1,2 @@
+export type CopyKey = "operation.saved" | "operation.failed" | "accounts" | "accounts.empty" | "create" | "create.description" | "create.groups" | "create.name" | "create.platform" | "create.save" | "create.unavailable" | "configuration" | "configuration.description" | "configuration.save" | "empty.search" | "export" | "logs" | "logs.empty" | "logs.load-more" | "runtime" | "sessions" | "sessions.empty" | "status.generation" | "status.inbound" | "status.outbound" | "status.state";
+export declare function copy(locale: string, key: CopyKey): string;

package/dist/bundled-plugins/@cordisx/channel/dist/locales.js

@@ -0,0 +1,59 @@
+const EN = {
+    "operation.saved": "Operation completed.",
+    "operation.failed": "Operation failed. Check the connection and try again.",
+    accounts: "Channel accounts",
+    "accounts.empty": "No channel accounts are available.",
+    create: "New channel",
+    "create.description": "Create a simulator connection or continue through Host-owned credential capture.",
+    "create.groups": "Allow group messages",
+    "create.name": "Display name",
+    "create.platform": "Platform",
+    "create.save": "Create channel",
+    "create.unavailable": "Channel creation is unavailable.",
+    configuration: "Configuration",
+    "configuration.description": "Update the safe display settings or run an available connection action.",
+    "configuration.save": "Save configuration",
+    "empty.search": "No channel accounts match this search.",
+    export: "Export",
+    logs: "Logs",
+    "logs.empty": "No safe log entries are available.",
+    "logs.load-more": "Load more",
+    runtime: "Runtime status",
+    sessions: "Connections & sessions",
+    "sessions.empty": "No session bindings are available.",
+    "status.generation": "Generation",
+    "status.inbound": "Inbound queued",
+    "status.outbound": "Outbound queued",
+    "status.state": "State",
+};
+const ZH = {
+    "operation.saved": "操作已完成",
+    "operation.failed": "操作未完成，请检查连接后重试",
+    accounts: "渠道账号",
+    "accounts.empty": "暂无可用渠道账号。",
+    create: "新建渠道",
+    "create.description": "创建模拟器连接，或继续使用 Host 所有的凭据捕获。",
+    "create.groups": "允许群消息",
+    "create.name": "显示名称",
+    "create.platform": "平台",
+    "create.save": "创建渠道",
+    "create.unavailable": "当前无法创建渠道。",
+    configuration: "配置",
+    "configuration.description": "更新安全显示设置，或执行当前可用的连接操作。",
+    "configuration.save": "保存配置",
+    "empty.search": "没有匹配搜索条件的渠道账号。",
+    export: "导出",
+    logs: "日志",
+    "logs.empty": "暂无安全日志记录。",
+    "logs.load-more": "加载更多",
+    runtime: "运行状态",
+    sessions: "连接与会话",
+    "sessions.empty": "暂无会话绑定。",
+    "status.generation": "代次",
+    "status.inbound": "入站队列",
+    "status.outbound": "出站队列",
+    "status.state": "状态",
+};
+export function copy(locale, key) {
+    return (locale.startsWith("zh") ? ZH : EN)[key];
+}

package/dist/bundled-plugins/@cordisx/channel/dist/model.d.ts

@@ -0,0 +1,40 @@
+import type { ChannelManagerAccountV3, ChannelManagerBindingV3, ChannelManagerSnapshotV3, ChannelManagerV2 } from "@cordisx/protocol/channel-manager/v2";
+export interface ChannelPageModel {
+    readonly manager: ChannelManagerV2;
+    readonly snapshot: ChannelManagerSnapshotV3;
+}
+export interface ChannelStore {
+    snapshot(): ChannelManagerSnapshotV3;
+    subscribe(listener: () => void): () => void;
+}
+export declare function createChannelStore(manager: ChannelManagerV2): ChannelStore;
+export declare function useChannelModel(manager: ChannelManagerV2): ChannelPageModel;
+export declare function requestId(): string;
+export declare function operationFence(snapshot: ChannelManagerSnapshotV3, expectedRevision?: number): {
+    readonly contract: "cordisx.channel-manager-request/v2";
+    readonly schemaVersion: 2;
+    readonly requestId: string;
+    readonly expectedRevision: number;
+    readonly profileId: string;
+    readonly hostGeneration: string;
+};
+export declare function targetFence(snapshot: ChannelManagerSnapshotV3, expectedRevision?: number): {
+    readonly contract: "cordisx.channel-manager-target-request/v1";
+    readonly schemaVersion: 1;
+    readonly requestId: string;
+    readonly expectedRevision: number;
+    readonly profileId: string;
+    readonly hostGeneration: string;
+};
+export declare function createChannelConnection(manager: ChannelManagerV2, snapshot: ChannelManagerSnapshotV3, input: {
+    readonly platform: "simulator" | "feishu" | "lark";
+    readonly displayName: string;
+    readonly selectors: readonly ("direct" | "group")[];
+}): Promise<"applied" | "conflict" | "rejected" | "unavailable">;
+export declare function routeToken(value: unknown): string | undefined;
+export declare function canCreateConnection(snapshot: ChannelManagerSnapshotV3, platform: "simulator" | "feishu" | "lark"): boolean;
+export declare function canQueryLogs(account: ChannelManagerAccountV3 | undefined): boolean;
+export declare function canExportLogs(account: ChannelManagerAccountV3 | undefined): boolean;
+export declare function accountByToken(snapshot: ChannelManagerSnapshotV3, token: string | undefined): ChannelManagerAccountV3 | undefined;
+export declare function bindingsForAccount(snapshot: ChannelManagerSnapshotV3, connectionToken: string): readonly ChannelManagerBindingV3[];
+export declare function stateLabel(locale: string, state: ChannelManagerAccountV3["connectionState"]): string;

package/dist/bundled-plugins/@cordisx/channel/dist/model.js

@@ -0,0 +1,135 @@
+import { useMemo, useSyncExternalStore } from "cordisx/react";
+export function createChannelStore(manager) {
+    let current = manager.snapshot();
+    let sourceSubscription;
+    const listeners = new Set();
+    const refresh = () => {
+        current = manager.snapshot();
+        for (const listener of listeners)
+            listener();
+    };
+    return {
+        snapshot: () => current,
+        subscribe: listener => {
+            listeners.add(listener);
+            if (sourceSubscription === undefined) {
+                sourceSubscription = manager.subscribe(refresh);
+                current = manager.snapshot();
+            }
+            return () => {
+                listeners.delete(listener);
+                if (listeners.size === 0) {
+                    sourceSubscription?.dispose();
+                    sourceSubscription = undefined;
+                }
+            };
+        },
+    };
+}
+export function useChannelModel(manager) {
+    const store = useMemo(() => createChannelStore(manager), [manager]);
+    return {
+        manager,
+        snapshot: useSyncExternalStore(store.subscribe, store.snapshot, store.snapshot),
+    };
+}
+export function requestId() {
+    return globalThis.crypto?.randomUUID?.() ?? `channel-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+export function operationFence(snapshot, expectedRevision = snapshot.revision) {
+    return {
+        contract: "cordisx.channel-manager-request/v2",
+        schemaVersion: 2,
+        requestId: requestId(),
+        expectedRevision,
+        profileId: snapshot.profileId,
+        hostGeneration: snapshot.hostGeneration,
+    };
+}
+export function targetFence(snapshot, expectedRevision = snapshot.revision) {
+    return {
+        contract: "cordisx.channel-manager-target-request/v1",
+        schemaVersion: 1,
+        requestId: requestId(),
+        expectedRevision,
+        profileId: snapshot.profileId,
+        hostGeneration: snapshot.hostGeneration,
+    };
+}
+export async function createChannelConnection(manager, snapshot, input) {
+    let issued;
+    if (input.platform === "simulator") {
+        issued = await manager.issue({
+            ...targetFence(snapshot),
+            operation: "target.connection.create.simulator",
+            adapterKind: "simulator",
+            target: { kind: "root" },
+        });
+        if (issued.status !== "applied" || issued.operation !== "target.connection.create.simulator"
+            || issued.target.kind !== "connection-draft")
+            return issued.status;
+    }
+    else {
+        const captureTarget = await manager.issue({
+            ...targetFence(snapshot),
+            operation: "target.credential.capture.create",
+            purpose: "create",
+            adapterKind: input.platform,
+            target: { kind: "root" },
+        });
+        if (captureTarget.status !== "applied" || captureTarget.operation !== "target.credential.capture.create"
+            || captureTarget.target.kind !== "credential-capture")
+            return captureTarget.status;
+        const captured = await manager.execute({
+            ...operationFence(snapshot, captureTarget.revision),
+            operation: "credential.capture",
+            target: captureTarget.target,
+        });
+        if (captured.status !== "applied" || captured.operation !== "credential.capture")
+            return captured.status;
+        issued = await manager.issue({
+            ...targetFence(snapshot, captured.revision),
+            operation: "target.connection.create",
+            target: { kind: "credential-draft", credentialDraftToken: captured.credentialDraftToken },
+        });
+        if (issued.status !== "applied" || issued.operation !== "target.connection.create"
+            || issued.target.kind !== "connection-draft")
+            return issued.status;
+    }
+    const result = await manager.execute({
+        ...operationFence(snapshot, issued.revision),
+        operation: "connection.create",
+        target: issued.target,
+        draft: { displayName: input.displayName, selectors: input.selectors },
+    });
+    return result.status;
+}
+export function routeToken(value) {
+    return typeof value === "string" ? value : undefined;
+}
+export function canCreateConnection(snapshot, platform) {
+    return snapshot.availableOperations.includes(platform === "simulator" ? "target.connection.create.simulator" : "target.credential.capture.create");
+}
+export function canQueryLogs(account) {
+    return account?.availableOperations.includes("logs.query") ?? false;
+}
+export function canExportLogs(account) {
+    return account?.availableOperations.includes("logs.export") ?? false;
+}
+export function accountByToken(snapshot, token) {
+    return snapshot.accounts.find(account => account.connectionToken === token);
+}
+export function bindingsForAccount(snapshot, connectionToken) {
+    return snapshot.bindings.filter(binding => binding.connectionToken === connectionToken);
+}
+export function stateLabel(locale, state) {
+    const labels = {
+        disabled: ["Disabled", "已停用"],
+        starting: ["Starting", "启动中"],
+        ready: ["Connected", "已连接"],
+        retrying: ["Retrying", "重试中"],
+        unavailable: ["Unavailable", "不可用"],
+        stopped: ["Stopped", "已停止"],
+    };
+    return labels[state][locale.startsWith("zh") ? 1 : 0];
+}

package/dist/bundled-plugins/@cordisx/channel/dist/notifications.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelPageProps } from "./page-types.js";
+export declare function notifyResult(props: ChannelPageProps, kind: string, success: boolean): void;

package/dist/bundled-plugins/@cordisx/channel/dist/notifications.js

@@ -0,0 +1,8 @@
+import { copy } from "./locales.js";
+export function notifyResult(props, kind, success) {
+    props.notifications.show({
+        kind,
+        type: success ? "success" : "error",
+        message: copy(props.locale, success ? "operation.saved" : "operation.failed"),
+    });
+}

package/dist/bundled-plugins/@cordisx/channel/dist/page-types.d.ts

@@ -0,0 +1,7 @@
+import type { ChannelManagerV2 } from "@cordisx/protocol/channel-manager/v2";
+import type { CordisXReactPageProps, NotificationsV1 } from "cordisx/contracts";
+export interface ChannelPageProps extends CordisXReactPageProps {
+    readonly notifications: NotificationsV1;
+    readonly manager: ChannelManagerV2;
+    readonly locale: string;
+}

package/dist/bundled-plugins/@cordisx/channel/dist/page-types.js

@@ -0,0 +1 @@
+export {};

package/dist/bundled-plugins/@cordisx/channel/dist/page.d.ts

@@ -0,0 +1,3 @@
+import type { ChannelManagerV2 } from "@cordisx/protocol/channel-manager/v2";
+import type { CordisXReactPageProps, NotificationsV1 } from "cordisx/contracts";
+export declare function createChannelPage(manager: ChannelManagerV2, notifications: NotificationsV1): (props: CordisXReactPageProps) => import("react").JSX.Element;

package/dist/bundled-plugins/@cordisx/channel/dist/page.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "cordisx/react/jsx-runtime";
+import { ChannelConfiguration } from "./pages/configuration.js";
+import { ChannelCreate } from "./pages/create.js";
+import { ChannelList } from "./pages/list.js";
+import { ChannelLogs } from "./pages/logs.js";
+import { ChannelRuntime } from "./pages/runtime.js";
+import { ChannelSessions } from "./pages/sessions.js";
+export function createChannelPage(manager, notifications) {
+    return function ChannelPage(props) {
+        const shared = { ...props, manager, notifications, locale: props.localization.getSnapshot().locale };
+        if (props.routeId.endsWith(":settings"))
+            return _jsx(ChannelList, { ...shared });
+        if (props.routeId.endsWith(":create"))
+            return _jsx(ChannelCreate, { ...shared });
+        if (props.routeId.endsWith(":runtime"))
+            return _jsx(ChannelRuntime, { ...shared });
+        if (props.routeId.endsWith(":logs"))
+            return _jsx(ChannelLogs, { ...shared });
+        if (props.routeId.endsWith(":sessions"))
+            return _jsx(ChannelSessions, { ...shared });
+        return _jsx(ChannelConfiguration, { ...shared });
+    };
+}

package/dist/bundled-plugins/@cordisx/channel/dist/pages/configuration.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelPageProps } from "../page-types.js";
+export declare function ChannelConfiguration(props: ChannelPageProps): import("react").JSX.Element;

package/dist/bundled-plugins/@cordisx/channel/dist/pages/configuration.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "cordisx/react/jsx-runtime";
+import { notifyResult } from "../notifications.js";
+import { useState } from "cordisx/react";
+import { Button, EmptyState, Stack, Text } from "cordisx/ui";
+import { copy } from "../locales.js";
+import { accountByToken, operationFence, routeToken, useChannelModel } from "../model.js";
+import { ChannelShell } from "../shell.js";
+export function ChannelConfiguration(props) {
+    const { manager, snapshot } = useChannelModel(props.manager);
+    const account = accountByToken(snapshot, routeToken(props.params.connectionToken));
+    const [name, setName] = useState(account?.displayName ?? "");
+    const [busy, setBusy] = useState(false);
+    if (account === undefined) {
+        return (_jsx(ChannelShell, { status: "unavailable", children: _jsx(EmptyState, { title: copy(props.locale, "accounts.empty") }) }));
+    }
+    const run = async (operation) => {
+        setBusy(true);
+        try {
+            const target = { kind: "connection", connectionToken: account.connectionToken };
+            const result = await manager.execute(operation === "connection.update"
+                ? { ...operationFence(snapshot), operation, target, patch: { displayName: name.trim() } }
+                : { ...operationFence(snapshot), operation, target });
+            notifyResult(props, operation, result.status === "applied");
+        }
+        catch {
+            notifyResult(props, operation, false);
+        }
+        finally {
+            setBusy(false);
+        }
+    };
+    return (_jsx(ChannelShell, { status: account.implementationStatus, children: _jsxs(Stack, { gap: "medium", "data-channel-page": "detail", "data-channel-detail": account.connectionToken, children: [_jsx("div", { children: _jsx(Text, { tone: "muted", children: copy(props.locale, "configuration.description") }) }), _jsxs("label", { className: "cxc-channel-field-control", children: [_jsx("span", { className: "cxc-channel-field-title", children: copy(props.locale, "create.name") }), _jsx("input", { value: name, onChange: event => setName(event.currentTarget.value) })] }), _jsxs("div", { className: "cxc-channel-actions", children: [["connection.enable", "connection.disable", "connection.reconnect"].map(operation => (_jsx(Button, { disabled: busy || !account.availableOperations.includes(operation), onClick: () => void run(operation), children: operation.slice("connection.".length) }, operation))), _jsx(Button, { variant: "primary", disabled: busy || name.trim() === "" || !account.availableOperations.includes("connection.update"), onClick: () => void run("connection.update"), children: copy(props.locale, "configuration.save") })] })] }) }));
+}

package/dist/bundled-plugins/@cordisx/channel/dist/pages/create.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelPageProps } from "../page-types.js";
+export declare function ChannelCreate(props: ChannelPageProps): import("react").JSX.Element;

package/dist/bundled-plugins/@cordisx/channel/dist/pages/create.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, jsxs as _jsxs } from "cordisx/react/jsx-runtime";
+import { notifyResult } from "../notifications.js";
+import { useState } from "cordisx/react";
+import { Button, Icon, Stack, Text } from "cordisx/ui";
+import { copy } from "../locales.js";
+import { canCreateConnection, createChannelConnection, useChannelModel } from "../model.js";
+import { ChannelShell } from "../shell.js";
+export function ChannelCreate(props) {
+    const { manager, snapshot } = useChannelModel(props.manager);
+    const [platform, setPlatform] = useState("simulator");
+    const [name, setName] = useState("");
+    const [selectors, setSelectors] = useState(["direct"]);
+    const [busy, setBusy] = useState(false);
+    const available = canCreateConnection(snapshot, platform);
+    const submit = async (event) => {
+        event.preventDefault();
+        if (!available || name.trim() === "")
+            return;
+        setBusy(true);
+        try {
+            const result = await createChannelConnection(manager, snapshot, {
+                platform,
+                displayName: name.trim(),
+                selectors,
+            });
+            if (result === "applied") {
+                await props.navigation.navigate({ id: "settings" });
+            }
+            else
+                notifyResult(props, "connection.create", false);
+        }
+        catch {
+            notifyResult(props, "connection.create", false);
+        }
+        finally {
+            setBusy(false);
+        }
+    };
+    return (_jsx(ChannelShell, { status: available ? "implemented" : "unavailable", children: _jsxs("form", { className: "cxc-channel-form", "data-channel-page": "create", onSubmit: event => void submit(event), children: [_jsxs(Stack, { gap: "medium", children: [_jsx(Text, { tone: "muted", children: copy(props.locale, "create.description") }), _jsxs("label", { className: "cxc-channel-field-control", children: [_jsx("span", { className: "cxc-channel-field-title", children: copy(props.locale, "create.platform") }), _jsxs("select", { value: platform, onChange: event => setPlatform(event.currentTarget.value), children: [_jsx("option", { value: "simulator", children: "Simulator" }), _jsx("option", { value: "feishu", children: "Feishu" }), _jsx("option", { value: "lark", children: "Lark" })] })] }), _jsxs("label", { className: "cxc-channel-field-control", children: [_jsx("span", { className: "cxc-channel-field-title", children: copy(props.locale, "create.name") }), _jsx("input", { required: true, value: name, onChange: event => setName(event.currentTarget.value) })] }), _jsxs("label", { className: "cxc-channel-switch", children: [_jsx("input", { type: "checkbox", checked: selectors.includes("group"), onChange: event => setSelectors(event.currentTarget.checked ? ["direct", "group"] : ["direct"]) }), copy(props.locale, "create.groups")] })] }), _jsx("div", { className: "cxc-channel-actions", children: _jsxs(Button, { variant: "primary", type: "submit", disabled: busy || !available || name.trim() === "", children: [_jsx(Icon, { name: "success" }), copy(props.locale, "create.save")] }) })] }) }));
+}

package/dist/bundled-plugins/@cordisx/channel/dist/pages/list.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelPageProps } from "../page-types.js";
+export declare function ChannelList(props: ChannelPageProps): import("react").JSX.Element;

package/dist/bundled-plugins/@cordisx/channel/dist/pages/list.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs } from "cordisx/react/jsx-runtime";
+import { Button, EmptyState, Icon } from "cordisx/ui";
+import { useMemo, useState } from "cordisx/react";
+import { copy } from "../locales.js";
+import { stateLabel, useChannelModel } from "../model.js";
+import { ChannelShell } from "../shell.js";
+export function ChannelList(props) {
+    const { snapshot } = useChannelModel(props.manager);
+    const [query, setQuery] = useState("");
+    const accounts = useMemo(() => {
+        const needle = query.trim().toLowerCase();
+        return snapshot.accounts.filter(account => needle === "" || [account.displayName, account.adapterKind, account.connectionState]
+            .filter(Boolean).join(" ").toLowerCase().includes(needle));
+    }, [query, snapshot]);
+    return (_jsx(ChannelShell, { status: snapshot.accounts.length === 0 ? "unavailable" : "implemented", children: _jsxs("div", { "data-channel-page": "list", children: [_jsxs("div", { className: "cxc-channel-toolbar", role: "toolbar", "aria-label": copy(props.locale, "accounts"), children: [_jsxs("span", { className: "cxc-channel-search", children: [_jsx(Icon, { name: "search" }), _jsx("input", { type: "search", value: query, onChange: event => setQuery(event.currentTarget.value), "aria-label": copy(props.locale, "accounts") })] }), _jsx(Button, { "data-channel-create": "true", "aria-label": copy(props.locale, "create"), title: copy(props.locale, "create"), disabled: !snapshot.availableOperations.includes("target.connection.create.simulator"), onClick: () => void props.navigation.navigate({ id: "create" }), children: _jsx(Icon, { name: "create" }) })] }), accounts.length === 0
+                    ? (_jsx(EmptyState, { "data-host-collection": "channel-list", title: copy(props.locale, query.trim() === "" ? "accounts.empty" : "empty.search") }))
+                    : (_jsx("div", { className: "cxc-channel-list", "data-host-collection": "channel-list", children: accounts.map(account => (_jsxs("button", { type: "button", className: "cxc-channel-account", "data-collection-item": account.connectionToken, onClick: () => void props.navigation.navigate({
+                                id: "configuration",
+                                params: { connectionToken: account.connectionToken },
+                            }), children: [_jsx("span", { className: "cxc-channel-avatar", children: (account.displayName ?? account.adapterKind).slice(0, 2) }), _jsxs("span", { className: "cxc-channel-account-copy", children: [_jsx("strong", { children: account.displayName ?? account.adapterKind }), _jsx("span", { className: "cxc-channel-meta", children: account.adapterKind })] }), _jsx("span", { className: "cxc-channel-status", "data-state": account.connectionState, children: stateLabel(props.locale, account.connectionState) })] }, account.connectionToken))) }))] }) }));
+}

package/dist/bundled-plugins/@cordisx/channel/dist/pages/logs.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelPageProps } from "../page-types.js";
+export declare function ChannelLogs(props: ChannelPageProps): import("react").JSX.Element;

package/dist/bundled-plugins/@cordisx/channel/dist/pages/logs.js

@@ -0,0 +1,57 @@
+import { jsx as _jsx, jsxs as _jsxs } from "cordisx/react/jsx-runtime";
+import { notifyResult } from "../notifications.js";
+import { Button, EmptyState } from "cordisx/ui";
+import { useEffect, useState } from "cordisx/react";
+import { accountByToken, canExportLogs, canQueryLogs, operationFence, routeToken, useChannelModel } from "../model.js";
+import { copy } from "../locales.js";
+import { ChannelShell } from "../shell.js";
+export function ChannelLogs(props) {
+    const { manager, snapshot } = useChannelModel(props.manager);
+    const account = accountByToken(snapshot, routeToken(props.params.connectionToken));
+    const [entries, setEntries] = useState([]);
+    const [cursor, setCursor] = useState();
+    const canQuery = canQueryLogs(account);
+    const canExport = canExportLogs(account);
+    const load = async (next, append = false) => {
+        if (account === undefined || !canQuery)
+            return;
+        try {
+            const page = await manager.queryLogs({
+                ...operationFence(snapshot),
+                operation: "logs.query",
+                target: { kind: "log", connectionToken: account.connectionToken },
+                query: { limit: 25, ...(next === undefined ? {} : { cursor: next }) },
+            });
+            setEntries(current => append ? [...current, ...page.entries] : page.entries);
+            setCursor(page.nextCursor);
+        }
+        catch {
+            notifyResult(props, "logs.query", false);
+        }
+    };
+    useEffect(() => {
+        void load();
+    }, [account?.connectionToken, snapshot.revision]);
+    if (account === undefined) {
+        return (_jsx(ChannelShell, { status: "unavailable", children: _jsx(EmptyState, { title: copy(props.locale, "accounts.empty") }) }));
+    }
+    const exportLogs = async () => {
+        try {
+            const result = await manager.exportLogs({
+                ...operationFence(snapshot),
+                operation: "logs.export",
+                target: { kind: "log", connectionToken: account.connectionToken },
+                query: { limit: 1000 },
+            });
+            notifyResult(props, "logs.export", result.status === "created");
+        }
+        catch {
+            notifyResult(props, "logs.export", false);
+        }
+    };
+    return (_jsx(ChannelShell, { status: account.implementationStatus, children: _jsxs("section", { "data-channel-page": "detail", "data-channel-detail": account.connectionToken, "data-channel-logs": "true", children: [_jsxs("div", { className: "cxc-channel-toolbar", role: "toolbar", "aria-label": copy(props.locale, "logs"), children: [_jsx(Button, { disabled: !canQuery, onClick: () => void load(), children: copy(props.locale, "logs") }), _jsx(Button, { disabled: !canExport, onClick: () => void exportLogs(), children: copy(props.locale, "export") })] }), entries.length === 0
+                    ? _jsx(EmptyState, { title: copy(props.locale, "logs.empty") })
+                    : (_jsx("div", { className: "cxc-channel-data-list", children: entries.map(entry => (_jsxs("article", { className: "cxc-channel-log-entry", children: [_jsx("time", { dateTime: entry.occurredAt, children: new Date(entry.occurredAt).toLocaleString(props.locale) }), _jsx("span", { children: entry.event }), _jsx("span", { className: "cxc-channel-log-outcome", children: entry.code })] }, entry.entryId))) })), cursor === undefined
+                    ? null
+                    : _jsx(Button, { onClick: () => void load(cursor, true), children: copy(props.locale, "logs.load-more") })] }) }));
+}

package/dist/bundled-plugins/@cordisx/channel/dist/pages/runtime.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelPageProps } from "../page-types.js";
+export declare function ChannelRuntime(props: ChannelPageProps): import("react").JSX.Element;

package/dist/bundled-plugins/@cordisx/channel/dist/pages/runtime.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "cordisx/react/jsx-runtime";
+import { Card, EmptyState, Stack } from "cordisx/ui";
+import { copy } from "../locales.js";
+import { accountByToken, routeToken, stateLabel, useChannelModel } from "../model.js";
+import { ChannelShell } from "../shell.js";
+export function ChannelRuntime(props) {
+    const { snapshot } = useChannelModel(props.manager);
+    const account = accountByToken(snapshot, routeToken(props.params.connectionToken));
+    if (account === undefined) {
+        return (_jsx(ChannelShell, { status: "unavailable", children: _jsx(EmptyState, { title: copy(props.locale, "accounts.empty") }) }));
+    }
+    const stats = [
+        [copy(props.locale, "status.state"), stateLabel(props.locale, account.connectionState)],
+        [copy(props.locale, "status.inbound"), String(account.inbound.pending + account.inbound.retrying)],
+        [copy(props.locale, "status.outbound"), String(account.outbound.pending + account.outbound.retrying)],
+        [copy(props.locale, "status.generation"), String(account.generation)],
+    ];
+    return (_jsx(ChannelShell, { status: account.implementationStatus, children: _jsx(Stack, { gap: "medium", "data-channel-page": "detail", "data-channel-detail": account.connectionToken, children: _jsx("div", { className: "cxc-channel-cards", children: stats.map(([label, value]) => (_jsxs(Card, { className: "cxc-channel-stat", children: [_jsx("strong", { children: value }), _jsx("span", { children: label })] }, label))) }) }) }));
+}

package/dist/bundled-plugins/@cordisx/channel/dist/pages/sessions.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelPageProps } from "../page-types.js";
+export declare function ChannelSessions(props: ChannelPageProps): import("react").JSX.Element;

package/dist/bundled-plugins/@cordisx/channel/dist/pages/sessions.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "cordisx/react/jsx-runtime";
+import { Button, Card, EmptyState, Stack } from "cordisx/ui";
+import { useState } from "cordisx/react";
+import { bindingsForAccount, operationFence, routeToken, useChannelModel } from "../model.js";
+import { copy } from "../locales.js";
+import { ChannelShell } from "../shell.js";
+export function ChannelSessions(props) {
+    const { manager, snapshot } = useChannelModel(props.manager);
+    const token = routeToken(props.params.connectionToken);
+    const bindings = token === undefined ? [] : bindingsForAccount(snapshot, token);
+    const [busy, setBusy] = useState(false);
+    if (bindings.length === 0) {
+        return (_jsx(ChannelShell, { status: "unavailable", children: _jsx(EmptyState, { title: copy(props.locale, "sessions.empty") }) }));
+    }
+    const run = async (binding, operation) => {
+        setBusy(true);
+        try {
+            await manager.execute({
+                ...operationFence(snapshot),
+                operation,
+                target: {
+                    kind: "binding",
+                    bindingToken: binding.bindingToken,
+                    bindingRevision: binding.bindingRevision,
+                },
+            });
+        }
+        finally {
+            setBusy(false);
+        }
+    };
+    return (_jsx(ChannelShell, { status: "implemented", children: _jsx(Stack, { gap: "medium", "data-channel-page": "detail", "data-channel-detail": token, children: _jsx("div", { className: "cxc-channel-data-list", children: bindings.map(binding => (_jsxs(Card, { className: "cxc-channel-data-row", children: [_jsxs("span", { className: "cxc-channel-data-copy", children: [_jsx("strong", { children: binding.state }), _jsxs("span", { className: "cxc-channel-meta", children: ["Revision ", binding.bindingRevision] })] }), _jsx("span", { className: "cxc-channel-actions", children: binding.availableOperations.map(operation => (_jsx(Button, { disabled: busy, onClick: () => void run(binding, operation), children: operation.slice("binding.".length) }, operation))) })] }, binding.bindingToken))) }) }) }));
+}

package/dist/bundled-plugins/@cordisx/channel/dist/service.mjs

@@ -0,0 +1,62 @@
+export const name = "channel-runtime";
+export const inject = ["channel"];
+
+const SIMULATOR_REF = Object.freeze({ adapterId: "simulator", accountId: "local", tenantId: "test" });
+
+function validateConfig(value) {
+  if (
+    value === null || typeof value !== "object" || Array.isArray(value)
+    || value.contract !== "cordisx.channel-service-config/v1" || value.schemaVersion !== 1
+    || !Array.isArray(value.connections)
+  ) {
+    throw new TypeError("Channel service configuration is invalid");
+  }
+  return value;
+}
+
+function simulatorDefinition(connection, configurationRevision) {
+  const sent = new Map();
+  return {
+    descriptor: {
+      ref: connection.ref,
+      kind: "simulator",
+      implementationStatus: "verified",
+      configurationRevision,
+      secretState: "unavailable",
+    },
+    start: async () => ({
+      send: async delivery => {
+        const prior = sent.get(delivery.deliveryId);
+        if (prior !== undefined) return prior;
+        const result = { externalMessageId: `simulated-${delivery.deliveryId}` };
+        sent.set(delivery.deliveryId, result);
+        return result;
+      },
+      stop: async () => {},
+    }),
+  };
+}
+
+/**
+ * The immutable service artifact owns the simulator only. Official Feishu/Lark
+ * definitions remain Host-owned because the plugin never receives credentials
+ * or a secret resolver.
+ */
+export async function apply(ctx, input) {
+  const config = validateConfig(input);
+  const configurationRevision = ctx.channel.configuration.revision;
+  if (!Number.isInteger(configurationRevision) || configurationRevision < 1) {
+    throw new TypeError("Channel service configuration revision is invalid");
+  }
+  for (const connection of config.connections) {
+    if (!connection.enabled) continue;
+    if (
+      connection.adapterKind === "simulator" && connection.transport?.mode === "simulator"
+      && connection.ref?.adapterId === SIMULATOR_REF.adapterId
+      && connection.ref?.accountId === SIMULATOR_REF.accountId
+      && connection.ref?.tenantId === SIMULATOR_REF.tenantId
+    ) {
+      await ctx.channel.adapters.register(simulatorDefinition(connection, configurationRevision));
+    }
+  }
+}

package/dist/bundled-plugins/@cordisx/channel/dist/shell.d.ts

@@ -0,0 +1,5 @@
+import type { ReactNode } from "cordisx/react";
+export declare function ChannelShell(props: {
+    readonly children: ReactNode;
+    readonly status: string;
+}): import("react").JSX.Element;

package/dist/bundled-plugins/@cordisx/channel/dist/shell.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "cordisx/react/jsx-runtime";
+import styles from "./channel.css";
+export function ChannelShell(props) {
+    return (_jsxs("section", { className: "cxc-channel-react", "data-channel-manager": "mounted", "data-channel-status": props.status, children: [_jsx("style", { children: styles }), props.children] }));
+}

package/dist/bundled-plugins/@cordisx/channel/dist/status.d.ts

@@ -0,0 +1,6 @@
+/** Executable owner candidate consuming the formal public Host provider. */
+export declare const CHANNEL_PLUGIN_STATUS: "package-verification";
+export declare const REQUIRED_BASELINES: Readonly<{
+    host: "dfb071e02eca0ef52f84d67b2393c25aced7d3f0";
+    protocol: "3f0dbcd8b04ae83c920d2d913ac2c313af5f83f1";
+}>;

package/dist/bundled-plugins/@cordisx/channel/dist/status.js

@@ -0,0 +1,6 @@
+/** Executable owner candidate consuming the formal public Host provider. */
+export const CHANNEL_PLUGIN_STATUS = "package-verification";
+export const REQUIRED_BASELINES = Object.freeze({
+    host: "dfb071e02eca0ef52f84d67b2393c25aced7d3f0",
+    protocol: "3f0dbcd8b04ae83c920d2d913ac2c313af5f83f1",
+});