@proto.ui/adapter-base 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Proto UI Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,48 @@
+# @proto.ui/adapter-base
+
+Base package for building Proto UI adapters.
+
+## Purpose
+
+Provides the base template, shared host wiring, and common runtime bridges for building Proto UI adapters.
+
+## Package Role
+
+Adapter foundation package used to translate Proto UI contracts into concrete host integrations.
+
+## Install
+
+```bash
+npm install @proto.ui/adapter-base@0.0.1
+```
+
+## Internal Structure
+
+- `src/events/`
+- `src/gate/`
+- `src/host/`
+- `src/index.ts`
+- `src/lifecycle/`
+- `src/types.ts`
+- `src/wiring/`
+
+## Related Internal Packages
+
+- `@proto.ui/core`
+- `@proto.ui/module-anatomy`
+- `@proto.ui/module-as-trigger`
+- `@proto.ui/module-context`
+- `@proto.ui/module-event`
+- `@proto.ui/module-expose`
+- `@proto.ui/module-expose-state-web`
+- `@proto.ui/module-feedback`
+- `@proto.ui/module-focus`
+- `@proto.ui/module-props`
+- `@proto.ui/module-rule-expose-state-web`
+- `@proto.ui/module-rule-meta`
+- `@proto.ui/runtime`
+- `@proto.ui/types`
+
+## License
+
+MIT

package/dist/events/web-event-router.d.ts

@@ -0,0 +1,10 @@
+export declare function createWebProtoEventRouter(opt: {
+    rootEl: HTMLElement;
+    globalEl?: EventTarget;
+    isEnabled: () => boolean;
+}): {
+    /** Inject these into EVENT_*_TARGET_CAP */
+    rootTarget: EventTarget;
+    globalTarget: EventTarget;
+    dispose(): void;
+};

package/dist/events/web-event-router.js

@@ -0,0 +1,195 @@
+// packages/adapters/base/src/events/web-event-router.ts
+export function createWebProtoEventRouter(opt) {
+    // proto semantic bus: press.*, pointer.*, key.*, context.menu...
+    const protoRootBus = new EventTarget();
+    const protoGlobalBus = new EventTarget();
+    const rootEl = opt.rootEl;
+    const globalEl = opt.globalEl ?? window;
+    // --- helper: emit proto event to proto bus ---
+    function emit(target, type, native) {
+        const ev = new CustomEvent(type, { detail: native });
+        target.dispatchEvent(ev);
+    }
+    // -------------------------
+    // (A) 固定监听：解释“协议语义事件”
+    // -------------------------
+    // 这些是你愿意为每个组件实例支付的固定成本（尽量少）
+    const unsubs = [];
+    // pointer -> pointer.*
+    unsubs.push(listen(rootEl, 'pointerdown', (e) => {
+        if (!opt.isEnabled())
+            return;
+        emit(protoRootBus, 'pointer.down', e);
+    }));
+    unsubs.push(listen(rootEl, 'pointermove', (e) => {
+        if (!opt.isEnabled())
+            return;
+        emit(protoRootBus, 'pointer.move', e);
+    }));
+    unsubs.push(listen(rootEl, 'pointerup', (e) => {
+        if (!opt.isEnabled())
+            return;
+        emit(protoRootBus, 'pointer.up', e);
+    }));
+    unsubs.push(listen(rootEl, 'pointercancel', (e) => {
+        if (!opt.isEnabled())
+            return;
+        emit(protoRootBus, 'pointer.cancel', e);
+    }));
+    unsubs.push(listen(rootEl, 'pointerenter', (e) => {
+        if (!opt.isEnabled())
+            return;
+        emit(protoRootBus, 'pointer.enter', e);
+    }));
+    unsubs.push(listen(rootEl, 'pointerleave', (e) => {
+        if (!opt.isEnabled())
+            return;
+        emit(protoRootBus, 'pointer.leave', e);
+    }));
+    // key -> key.* (global)
+    unsubs.push(listen(globalEl, 'keydown', (e) => {
+        if (!opt.isEnabled())
+            return;
+        emit(protoGlobalBus, 'key.down', e);
+        // minimal v0 mapping: activate keys => press.commit
+        if (e.key === 'Enter' || e.key === ' ') {
+            emit(protoRootBus, 'press.commit', e);
+        }
+    }));
+    unsubs.push(listen(globalEl, 'keyup', (e) => {
+        if (!opt.isEnabled())
+            return;
+        emit(protoGlobalBus, 'key.up', e);
+    }));
+    // click -> press.commit (root)
+    unsubs.push(listen(rootEl, 'click', (e) => {
+        if (!opt.isEnabled())
+            return;
+        emit(protoRootBus, 'press.commit', e);
+    }));
+    // contextmenu -> context.menu
+    unsubs.push(listen(rootEl, 'contextmenu', (e) => {
+        if (!opt.isEnabled())
+            return;
+        emit(protoRootBus, 'context.menu', e);
+    }));
+    // -------------------------
+    // (B) 懒绑定：native:* / host.*
+    // -------------------------
+    const rootProxy = createProxyTarget({
+        protoBus: protoRootBus,
+        nativeTarget: rootEl,
+        // hostTarget：先工作假设= nativeTarget；未来你可以换成更准确的 host 专用 target
+        hostTarget: rootEl,
+        isEnabled: opt.isEnabled,
+        // 注：rootProxy 不做“解释”，只做“路由 + gating”
+    });
+    const globalProxy = createProxyTarget({
+        protoBus: protoGlobalBus,
+        nativeTarget: globalEl,
+        hostTarget: globalEl,
+        isEnabled: opt.isEnabled,
+    });
+    return {
+        /** Inject these into EVENT_*_TARGET_CAP */
+        rootTarget: rootProxy,
+        globalTarget: globalProxy,
+        dispose() {
+            for (const u of unsubs.splice(0))
+                u();
+            rootProxy.__dispose?.();
+            globalProxy.__dispose?.();
+        },
+    };
+}
+function listen(t, type, cb) {
+    t.addEventListener(type, cb);
+    return () => t.removeEventListener(type, cb);
+}
+function createProxyTarget(args) {
+    // 记录已转发到 native/host 的监听器，便于 remove 时精确解绑
+    const nativeListeners = [];
+    const hostListeners = [];
+    // 为 native/host 分支加 gating：eventGate disable 后，这些也不应该再进 proto 回调
+    // 这点非常关键，否则“unmount 后还能触发回调”的竞态会回来。
+    function wrapWithGate(cb) {
+        return (ev) => {
+            if (!args.isEnabled())
+                return;
+            cb(ev);
+        };
+    }
+    function parseType(type) {
+        if (type.startsWith('native:')) {
+            return { kind: 'native', inner: type.slice('native:'.length) };
+        }
+        if (type.startsWith('host.')) {
+            return { kind: 'host', inner: type.slice('host.'.length) };
+        }
+        return { kind: 'proto', inner: type };
+    }
+    const api = {
+        addEventListener(type, cb, options) {
+            const p = parseType(String(type));
+            if (p.kind === 'proto') {
+                // proto semantic event: on proto bus
+                args.protoBus.addEventListener(p.inner, cb, options);
+                return;
+            }
+            if (p.kind === 'native') {
+                const wrapped = wrapWithGate(cb);
+                nativeListeners.push({ type: p.inner, cb, options, wrapped });
+                args.nativeTarget.addEventListener(p.inner, wrapped, options);
+                return;
+            }
+            // host.*
+            const wrapped = wrapWithGate(cb);
+            hostListeners.push({ type: p.inner, cb, options, wrapped });
+            args.hostTarget.addEventListener(p.inner, wrapped, options);
+        },
+        removeEventListener(type, cb, options) {
+            const p = parseType(String(type));
+            if (p.kind === 'proto') {
+                args.protoBus.removeEventListener(p.inner, cb, options);
+                return;
+            }
+            const list = p.kind === 'native' ? nativeListeners : hostListeners;
+            const target = p.kind === 'native' ? args.nativeTarget : args.hostTarget;
+            // latest-first removal aligns with your v0 matching习惯
+            for (let i = list.length - 1; i >= 0; i--) {
+                const r = list[i];
+                if (r.type !== p.inner)
+                    continue;
+                if (r.cb !== cb)
+                    continue;
+                // options 匹配这里先用 Object.is（和 DOM 一样复杂就复杂了）
+                // 你若坚持“plain object shallow compare”，可以把 sameOptions 搬进来
+                if (!Object.is(r.options, options))
+                    continue;
+                target.removeEventListener(p.inner, r.wrapped, options);
+                list.splice(i, 1);
+                return;
+            }
+        },
+        dispatchEvent(ev) {
+            // 对外暴露的 dispatch：默认只派发到 protoBus
+            // （nativeTarget/hostTarget 的 dispatch 由真实 DOM 自己完成）
+            return args.protoBus.dispatchEvent(ev);
+        },
+        // best-effort cleanup (not required by EventTarget)
+        __dispose() {
+            // 主动解绑所有已懒绑定的 native/host listener，避免残留
+            for (const r of nativeListeners.splice(0)) {
+                args.nativeTarget.removeEventListener(r.type, 
+                // @ts-ignore
+                r.wrapped, r.options);
+            }
+            for (const r of hostListeners.splice(0)) {
+                args.hostTarget.removeEventListener(r.type, 
+                // @ts-ignore
+                r.wrapped, r.options);
+            }
+        },
+    };
+    return api;
+}

package/dist/gate/event-gate.d.ts

@@ -0,0 +1,8 @@
+export type EventGate = {
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    assertEnabled(hint?: string): void;
+    dispose(): void;
+};
+export declare function createEventGate(): EventGate;

package/dist/gate/event-gate.js

@@ -0,0 +1,26 @@
+export function createEventGate() {
+    let enabled = false;
+    let disposed = false;
+    return {
+        enable() {
+            if (disposed)
+                return;
+            enabled = true;
+        },
+        disable() {
+            enabled = false;
+        },
+        isEnabled() {
+            return enabled && !disposed;
+        },
+        assertEnabled(hint) {
+            if (!enabled || disposed) {
+                throw new Error(`[EventGate] event is not effective${hint ? `: ${hint}` : ''}`);
+            }
+        },
+        dispose() {
+            disposed = true;
+            enabled = false;
+        },
+    };
+}

package/dist/host/adapter-host.d.ts

@@ -0,0 +1,15 @@
+import type { Prototype } from '@proto.ui/core';
+import type { PropsBaseType } from '@proto.ui/types';
+import { type RuntimeHost, type ExecuteWithHostResult } from '@proto.ui/runtime';
+export type AdapterHostHooks<P extends PropsBaseType> = {
+    onRuntimeReady?: RuntimeHost<P>['onRuntimeReady'];
+    onUnmountBegin?: RuntimeHost<P>['onUnmountBegin'];
+    afterUnmount?: () => void;
+};
+export type AdapterHostInput<P extends PropsBaseType> = Pick<RuntimeHost<P>, 'commit' | 'schedule' | 'getRawProps'>;
+export type AdapterHostSession<P extends PropsBaseType> = {
+    controller: ExecuteWithHostResult['controller'];
+    dispose(): void;
+    caps: ExecuteWithHostResult['caps'];
+};
+export declare function createAdapterHost<P extends PropsBaseType>(proto: Prototype<P>, host: AdapterHostInput<P>, hooks?: AdapterHostHooks<P>): AdapterHostSession<P>;

package/dist/host/adapter-host.js

@@ -0,0 +1,23 @@
+import { executeWithHost } from '@proto.ui/runtime';
+import { createTeardown } from '../lifecycle/teardown';
+export function createAdapterHost(proto, host, hooks = {}) {
+    const teardown = createTeardown();
+    const res = executeWithHost(proto, {
+        prototypeName: proto.name,
+        getRawProps: host.getRawProps,
+        commit: host.commit,
+        schedule: host.schedule,
+        onRuntimeReady: hooks.onRuntimeReady,
+        onUnmountBegin: hooks.onUnmountBegin,
+    });
+    return {
+        controller: res.controller,
+        caps: res.caps,
+        dispose() {
+            teardown.run(() => {
+                res.invokeUnmounted();
+                hooks.afterUnmount?.();
+            });
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './wiring/host-wiring';
+export * from './wiring/caps-builder';
+export * from './gate/event-gate';
+export * from './lifecycle/teardown';
+export * from './host/adapter-host';
+export * from './events/web-event-router';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,8 @@
+// packages/adapters/base/src/index.ts
+export * from './wiring/host-wiring';
+export * from './wiring/caps-builder';
+export * from './gate/event-gate';
+export * from './lifecycle/teardown';
+export * from './host/adapter-host';
+export * from './events/web-event-router';
+export * from './types';

package/dist/lifecycle/teardown.d.ts

@@ -0,0 +1,4 @@
+export declare function createTeardown(): {
+    run(fn: () => void): void;
+    isDone(): boolean;
+};

package/dist/lifecycle/teardown.js

@@ -0,0 +1,15 @@
+// packages/adapters/base/src/lifecycle/teardown.ts
+export function createTeardown() {
+    let done = false;
+    return {
+        run(fn) {
+            if (done)
+                return;
+            done = true;
+            fn();
+        },
+        isDone() {
+            return done;
+        },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,15 @@
+import { CapEntries } from '@proto.ui/core';
+import type { ModuleWiring } from '@proto.ui/runtime';
+export type ModuleName = string;
+export type WiringSpec = Record<ModuleName, (init: {
+    prototypeName: string;
+}) => CapEntries>;
+export type HostWiring = {
+    onRuntimeReady(wiring: ModuleWiring): void;
+    onUnmountBegin?(): void;
+    /**
+     * Called AFTER invokeUnmounted() completed (modules are disposed),
+     * for adapter-owned cleanup only.
+     */
+    afterUnmount(): void;
+};

package/dist/types.js

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

package/dist/wiring/caps-builder.d.ts

@@ -0,0 +1,59 @@
+import type { CapEntries } from '@proto.ui/core';
+import type { WiringSpec } from '../types';
+import { type RawPropsSource } from '@proto.ui/module-props';
+import { type EventEmitSink, type EventTargetGetter } from '@proto.ui/module-event';
+import { type ExposeHostSink } from '@proto.ui/module-expose';
+import { type ExposeStateWebMode, type ExposeStateWebNameMap } from '@proto.ui/module-expose-state-web';
+import { type AnatomyInstanceToken, type AnatomyParentGetter, type AnatomyPrototypeGetter } from '@proto.ui/module-anatomy';
+import { type ContextParentGetter, type ContextInstanceToken } from '@proto.ui/module-context';
+import { type AsTriggerInstanceToken, type AsTriggerParentGetter, type AsTriggerPrototypeGetter } from '@proto.ui/module-as-trigger';
+import { type RuleMetaGetter } from '@proto.ui/module-rule-meta';
+import { type RuleExposeStateWebNativeVariantPolicy } from '@proto.ui/module-rule-expose-state-web';
+import { type FocusBlur, type FocusInstanceToken, type FocusIsNativelyFocusable, type FocusParentGetter, type FocusRequestFocus, type FocusRootTargetGetter, type FocusSetFocusable } from '@proto.ui/module-focus';
+import type { EffectsPort } from '@proto.ui/core';
+import type { PropsBaseType } from '@proto.ui/types';
+export type CapsWiringBuilder = {
+    add(moduleName: string, provide: () => CapEntries): CapsWiringBuilder;
+    useProps<P extends PropsBaseType>(source: RawPropsSource<P>): CapsWiringBuilder;
+    useFeedback(effects: EffectsPort): CapsWiringBuilder;
+    useEventTargets(args: {
+        root: EventTargetGetter;
+        global: EventTargetGetter;
+        emit?: EventEmitSink;
+    }): CapsWiringBuilder;
+    useExposeState(setExposes: ExposeHostSink): CapsWiringBuilder;
+    useExposeStateWeb(args: {
+        host: HTMLElement;
+        nameMap: ExposeStateWebNameMap;
+        mode?: ExposeStateWebMode;
+    }): CapsWiringBuilder;
+    useContext(args: {
+        instance: ContextInstanceToken;
+        parent: ContextParentGetter;
+    }): CapsWiringBuilder;
+    useAnatomy(args: {
+        instance: AnatomyInstanceToken;
+        parent: AnatomyParentGetter;
+        getPrototype: AnatomyPrototypeGetter;
+    }): CapsWiringBuilder;
+    useAsTrigger(args: {
+        instance: AsTriggerInstanceToken;
+        parent: AsTriggerParentGetter;
+        getPrototype: AsTriggerPrototypeGetter;
+    }): CapsWiringBuilder;
+    useFocus(args: {
+        instance: FocusInstanceToken;
+        parent: FocusParentGetter;
+        root: FocusRootTargetGetter;
+        isNativelyFocusable: FocusIsNativelyFocusable;
+        setFocusable: FocusSetFocusable;
+        requestFocus: FocusRequestFocus;
+        blur: FocusBlur;
+    }): CapsWiringBuilder;
+    useRuleMeta(getMeta: RuleMetaGetter): CapsWiringBuilder;
+    useRuleExposeStateWeb(args: {
+        nativeVariantPolicy: RuleExposeStateWebNativeVariantPolicy;
+    }): CapsWiringBuilder;
+    build(): WiringSpec;
+};
+export declare function createCapsWiring(): CapsWiringBuilder;

package/dist/wiring/caps-builder.js

@@ -0,0 +1,87 @@
+import { RAW_PROPS_SOURCE_CAP } from '@proto.ui/module-props';
+import { EFFECTS_CAP } from '@proto.ui/module-feedback';
+import { EVENT_GLOBAL_TARGET_CAP, EVENT_EMIT_CAP, EVENT_ROOT_TARGET_CAP, } from '@proto.ui/module-event';
+import { EXPOSE_SET_EXPOSES_CAP } from '@proto.ui/module-expose';
+import { EXPOSE_STATE_WEB_MAP_CAP, EXPOSE_STATE_WEB_MODE_CAP, HOST_ELEMENT_CAP, } from '@proto.ui/module-expose-state-web';
+import { ANATOMY_GET_PROTO_CAP, ANATOMY_INSTANCE_TOKEN_CAP, ANATOMY_PARENT_CAP, } from '@proto.ui/module-anatomy';
+import { CONTEXT_INSTANCE_TOKEN_CAP, CONTEXT_PARENT_CAP, } from '@proto.ui/module-context';
+import { AS_TRIGGER_GET_PROTO_CAP, AS_TRIGGER_INSTANCE_CAP, AS_TRIGGER_PARENT_CAP, } from '@proto.ui/module-as-trigger';
+import { RULE_META_GET_CAP } from '@proto.ui/module-rule-meta';
+import { RULE_EXPOSE_STATE_WEB_NATIVE_VARIANT_POLICY_CAP, } from '@proto.ui/module-rule-expose-state-web';
+import { FOCUS_BLUR_CAP, FOCUS_INSTANCE_TOKEN_CAP, FOCUS_IS_NATIVELY_FOCUSABLE_CAP, FOCUS_PARENT_CAP, FOCUS_REQUEST_FOCUS_CAP, FOCUS_ROOT_TARGET_CAP, FOCUS_SET_FOCUSABLE_CAP, } from '@proto.ui/module-focus';
+export function createCapsWiring() {
+    const modules = {};
+    const add = (moduleName, provide) => {
+        modules[moduleName] = provide;
+        return api;
+    };
+    const api = {
+        add,
+        useProps(source) {
+            return add('props', () => [[RAW_PROPS_SOURCE_CAP, source]]);
+        },
+        useFeedback(effects) {
+            return add('feedback', () => [[EFFECTS_CAP, effects]]);
+        },
+        useEventTargets({ root, global, emit }) {
+            return add('event', () => [
+                [EVENT_ROOT_TARGET_CAP, root],
+                [EVENT_GLOBAL_TARGET_CAP, global],
+                ...(emit ? [[EVENT_EMIT_CAP, emit]] : []),
+            ]);
+        },
+        useExposeState(setExposes) {
+            return add('expose-state', () => [[EXPOSE_SET_EXPOSES_CAP, setExposes]]);
+        },
+        useExposeStateWeb({ host, nameMap, mode }) {
+            return add('expose-state-web', () => [
+                [HOST_ELEMENT_CAP, host],
+                [EXPOSE_STATE_WEB_MAP_CAP, nameMap],
+                ...(mode ? [[EXPOSE_STATE_WEB_MODE_CAP, mode]] : []),
+            ]);
+        },
+        useContext({ instance, parent }) {
+            return add('context', () => [
+                [CONTEXT_INSTANCE_TOKEN_CAP, instance],
+                [CONTEXT_PARENT_CAP, parent],
+            ]);
+        },
+        useAnatomy({ instance, parent, getPrototype }) {
+            return add('anatomy', () => [
+                [ANATOMY_INSTANCE_TOKEN_CAP, instance],
+                [ANATOMY_PARENT_CAP, parent],
+                [ANATOMY_GET_PROTO_CAP, getPrototype],
+            ]);
+        },
+        useAsTrigger({ instance, parent, getPrototype }) {
+            return add('as-trigger', () => [
+                [AS_TRIGGER_INSTANCE_CAP, instance],
+                [AS_TRIGGER_PARENT_CAP, parent],
+                [AS_TRIGGER_GET_PROTO_CAP, getPrototype],
+            ]);
+        },
+        useFocus({ instance, parent, root, isNativelyFocusable, setFocusable, requestFocus, blur }) {
+            return add('focus', () => [
+                [FOCUS_INSTANCE_TOKEN_CAP, instance],
+                [FOCUS_PARENT_CAP, parent],
+                [FOCUS_ROOT_TARGET_CAP, root],
+                [FOCUS_IS_NATIVELY_FOCUSABLE_CAP, isNativelyFocusable],
+                [FOCUS_SET_FOCUSABLE_CAP, setFocusable],
+                [FOCUS_REQUEST_FOCUS_CAP, requestFocus],
+                [FOCUS_BLUR_CAP, blur],
+            ]);
+        },
+        useRuleMeta(getMeta) {
+            return add('rule-meta', () => [[RULE_META_GET_CAP, getMeta]]);
+        },
+        useRuleExposeStateWeb({ nativeVariantPolicy }) {
+            return add('rule-expose-state-web', () => [
+                [RULE_EXPOSE_STATE_WEB_NATIVE_VARIANT_POLICY_CAP, nativeVariantPolicy],
+            ]);
+        },
+        build() {
+            return modules;
+        },
+    };
+    return api;
+}

package/dist/wiring/host-wiring.d.ts

@@ -0,0 +1,5 @@
+import type { HostWiring, WiringSpec } from '../types';
+export declare function createHostWiring(args: {
+    prototypeName: string;
+    modules: WiringSpec;
+}): HostWiring;

package/dist/wiring/host-wiring.js

@@ -0,0 +1,30 @@
+export function createHostWiring(args) {
+    const { prototypeName, modules } = args;
+    const wired = new Set();
+    let wiringApi = null;
+    return {
+        onRuntimeReady(wiring) {
+            wiringApi = wiring;
+            for (const [name, provide] of Object.entries(modules)) {
+                const entries = provide({ prototypeName });
+                const ok = wiring.attach(name, entries);
+                if (ok)
+                    wired.add(name);
+            }
+        },
+        afterUnmount() {
+            if (!wiringApi)
+                return;
+            for (const name of wired) {
+                try {
+                    wiringApi.reset(name);
+                }
+                catch {
+                    // ignore v0
+                }
+            }
+            wired.clear();
+            wiringApi = null;
+        },
+    };
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@proto.ui/adapter-base",
+  "version": "0.0.1",
+  "type": "module",
+  "dependencies": {
+    "@proto.ui/core": "0.0.1",
+    "@proto.ui/runtime": "0.0.1",
+    "@proto.ui/types": "0.0.1",
+    "@proto.ui/module-props": "0.0.1",
+    "@proto.ui/module-feedback": "0.0.1",
+    "@proto.ui/module-event": "0.0.1",
+    "@proto.ui/module-expose": "0.0.1",
+    "@proto.ui/module-expose-state-web": "0.0.1",
+    "@proto.ui/module-rule-expose-state-web": "0.0.1",
+    "@proto.ui/module-rule-meta": "0.0.1",
+    "@proto.ui/module-context": "0.0.1",
+    "@proto.ui/module-anatomy": "0.0.1",
+    "@proto.ui/module-as-trigger": "0.0.1",
+    "@proto.ui/module-focus": "0.0.1"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "description": "Base package for building Proto UI adapters.",
+  "license": "MIT",
+  "homepage": "https://github.com/guangliang2019/Prototype-UI/tree/main/packages/adapters/base",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/guangliang2019/Prototype-UI.git",
+    "directory": "packages/adapters/base"
+  },
+  "bugs": {
+    "url": "https://github.com/guangliang2019/Prototype-UI/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "proto-ui",
+    "proto",
+    "ui",
+    "adapter",
+    "base",
+    "custom-adapter-hosts"
+  ],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
+}