skinsuite 0.2.3 → 0.3.1

package/dist/index.d.ts

@@ -42,14 +42,14 @@ export type { ThemeAssetModules } from './registry.js';
 export { listThemes, listColorsOf, toneOfColor, toneOfAnyScope, listColorIdsOfTone, resolveThemeId, getThemeRecord, getDefaultThemeId, isKnownTheme, listColorViews } from './registry.js';
 export { DEVICE_SCOPED_PARAMS, readDeviceParam } from './views/params.js';
 export type { DeviceScopedParam } from './views/params.js';
-export { asDeviceId, containersOf, deviceContext, deviceLabel, pickDeviceId } from './views/device.js';
-export type { DeviceDef, DeviceMatchContext } from './views/device.js';
 /**
- * 设备注册表工厂：一份 `DeviceDef[]` 清单 → 全套已绑定的判定机制。
- * 宿主不再逐个转发判定函数，只写清单、调一次工厂。
+ * 设备清单机制（只有事实与查询，**判定不在这里**）
+ *
+ * 「当前属于哪台设备」由宿主注入 `resolveDevice`（`skinsuite/vue`），库不认识
+ * 视口阈值 / UA / `?isMobile` / `?from=` 这些词汇。
  */
-export { createDeviceRegistry } from './views/device-registry.js';
-export type { DeviceRegistry, DeviceRegistryOptions } from './views/device-registry.js';
+export { asDeviceId, containersOf, deviceLabel } from './views/device.js';
+export type { DeviceDef } from './views/device.js';
 /**
  * 外部下发的主题配置：**只归一形状，不碰网络**
  *

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,wBAAwB,EACtB,gBAAgB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACnF,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAClF,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,mBAAmB,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEzF,YAAY,EACV,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACzE,YAAY,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EACL,UAAU,EACR,YAAY,EACd,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,cAAc,EACf,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC1E,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE3D,OAAO,EACL,UAAU,EACV,YAAY,EACZ,aAAa,EACb,WAAW,EACX,YAAY,EACb,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEvE;;;GAGG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAClE,YAAY,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAExF;;;;GAIG;AACH,OAAO,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AACzD,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;;;;GAKG;AACH,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,aAAa,EACd,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,kBAAkB,EAClB,qBAAqB,EACrB,cAAc,EACd,aAAa,EACd,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,wBAAwB,EACtB,gBAAgB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACnF,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAClF,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,mBAAmB,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEzF,YAAY,EACV,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACzE,YAAY,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EACL,UAAU,EACR,YAAY,EACd,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,cAAc,EACf,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC1E,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE3D;;;;;GAKG;AACH,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC1E,YAAY,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD;;;;GAIG;AACH,OAAO,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AACzD,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;;;;GAKG;AACH,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,aAAa,EACd,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,kBAAkB,EAClB,qBAAqB,EACrB,cAAc,EACd,aAAa,EACd,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -36,12 +36,13 @@ export { isSafeTokenName, isSafeTokenValue, isSafeTokenEntry, sanitizeOverrides
 export { buildThemeRegistry, installThemeRegistry } from './registry.js';
 export { listThemes, listColorsOf, toneOfColor, toneOfAnyScope, listColorIdsOfTone, resolveThemeId, getThemeRecord, getDefaultThemeId, isKnownTheme, listColorViews } from './registry.js';
 export { DEVICE_SCOPED_PARAMS, readDeviceParam } from './views/params.js';
-export { asDeviceId, containersOf, deviceContext, deviceLabel, pickDeviceId } from './views/device.js';
 /**
- * 设备注册表工厂：一份 `DeviceDef[]` 清单 → 全套已绑定的判定机制。
- * 宿主不再逐个转发判定函数，只写清单、调一次工厂。
+ * 设备清单机制（只有事实与查询，**判定不在这里**）
+ *
+ * 「当前属于哪台设备」由宿主注入 `resolveDevice`（`skinsuite/vue`），库不认识
+ * 视口阈值 / UA / `?isMobile` / `?from=` 这些词汇。
  */
-export { createDeviceRegistry } from './views/device-registry.js';
+export { asDeviceId, containersOf, deviceLabel } from './views/device.js';
 /**
  * 外部下发的主题配置：**只归一形状，不碰网络**
  *

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,wBAAwB,EACtB,gBAAgB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGnF,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGlF,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAUrB,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAEzE,OAAO,EACL,UAAU,EACR,YAAY,EACd,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,cAAc,EACf,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAG1E,OAAO,EACL,UAAU,EACV,YAAY,EACZ,aAAa,EACb,WAAW,EACX,YAAY,EACb,MAAM,mBAAmB,CAAC;AAG3B;;;GAGG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAGlE;;;;GAIG;AACH,OAAO,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAGzD;;;;;GAKG;AACH,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,aAAa,EACd,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,wBAAwB,EACtB,gBAAgB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGnF,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGlF,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAUrB,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAEzE,OAAO,EACL,UAAU,EACR,YAAY,EACd,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,cAAc,EACf,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAG1E;;;;;GAKG;AACH,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAG1E;;;;GAIG;AACH,OAAO,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAGzD;;;;;GAKG;AACH,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,aAAa,EACd,MAAM,eAAe,CAAC"}

package/dist/views/device.d.ts

@@ -1,40 +1,31 @@
 /**
- * 设备清单机制（**纯逻辑半边**）—— 「哪些设备、怎么判定」的唯一实现（内核版）
+ * 设备清单机制（**纯逻辑半边**）—— 只描述「有哪些设备、占哪条路由、容器在哪」
  *
- * === 设备 = 路由 + 容器 = 版式信息的一部分 ===
- * 「有哪些设备」是宿主的部署事实（每个应用设备不同、容器位置不同），所以**设备清单
- * （`DeviceDef[]`）由宿主声明**；但「怎么从清单判定出当前设备、怎么归一化外部输入、
- * 怎么取容器」是**通用机制**，收在这里 —— 加一种设备时宿主只加一条声明，判定逻辑零改动。
+ * === 🔴 判定不在这里（2026-10-19 收口）===
+ * 「当前属于哪台设备」是**宿主的业务判定**，不是通用机制：
+ *   · 视口阈值（768 / 1024）、UA 兜底口径 —— 换个产品就变
+ *   · 宿主自己的 URL 词汇（`?isMobile` / `?from=mini` / `?device=` 锁定）—— 更是宿主专有
+ * 一旦下沉，库就得认识这些词汇，别的宿主复用机制时被迫沿用同一套约定；而本库对外
+ * 承诺的只有「设备域」这件机制本身。
  *
- * === 为什么这里只有「判定」、没有「组件」 ===
- * 本文件是**纯逻辑**（不含 `Component` 类型），能被内核 tsc 独立检查、也能被任何前端复用。
- * `containers` 用泛型 `T` 表达（宿主的「设备容器加载器」是 `T`），组件加载的**具体机制**
- * （`pageContainers` / `resolveContainerOf`）在 `skinsuite/vue` 的 `device-containers`，
- * 那里才 import Vue 的 `Component`。
+ * 所以判定改成**注入点**：宿主给 `app.use(theme, { router, resolveDevice })` 传一个
+ * `(ctx) => deviceId | null`，库把 router 的 `query / path / fullPath` **原样**递过去
+ * （只递事实，不带任何词汇），由宿主自己决定。库只负责：注册清单、记住当前设备、
+ * 通知订阅方、按设备取容器。
  *
- * === 判定顺序就是清单顺序（先命中先用），最后一条必须无条件成立 ===
- * 它是兜底设备。宿主关卡会核这一条。
+ * 由此「加一种设备」= 宿主加一条声明 + 一条判定分支，**库零改动**。
  *
- * === 为什么判定必须收在一处 ===
- * 三个分发器曾经各写一份「mini 来源」判定，口径不一致 → 同一个链接在不同页面落到
- * 不同设备。现在判定只有一份，各页面自然同形。
+ * === 为什么这里只有「设备」、没有「组件」 ===
+ * 本文件是**纯逻辑**（不含 `Component` 类型），能被内核 tsc 独立检查、也能被任何前端
+ * 复用。`containers` 用泛型 `T` 表达（宿主的「设备容器加载器」是 `T`），组件加载的
+ * **具体机制**（`pageContainers` / `resolveContainerOf`）在 `skinsuite/vue` 的
+ * `device-containers`，那里才 import Vue 的 `Component`。
  *
  * @author yijiu2025
  * @since 2026-10-17（从 oauth21/src/theme/devices.ts 下沉）
+ * @since 2026-10-19（判定层撤出：`match` / `DeviceMatchContext` / `pickDeviceId` /
+ *        `deviceContext` 全删，改为宿主注入 `resolveDevice`）
  */
-/** 判定上下文 —— 判定所需的**全部**外部信息（与页面无关的原始事实） */
-export interface DeviceMatchContext {
-    /** `?isMobile=true` —— 显式意图，优先级最高 */
-    explicitMobile: boolean;
-    /** 路由 path（不含 query / hash） */
-    path: string;
-    /** `?from=` 的取值（iframe 来源标记，空串表示没给） */
-    from: string;
-    /** `?fromLogin=` 的取值（历史键：从 mini 登录页跳来） */
-    fromLogin: string;
-    /** 视口/UA 判定结果 */
-    viewportIsMobile: boolean;
-}
 /** 一条设备声明（`containers` 是泛型：纯逻辑侧不关心它到底是什么，只透传） */
 export interface DeviceDef<T = unknown> {
     /** 设备 id = 主题包内的目录名，只允许 `[a-z0-9-]` */
@@ -47,17 +38,11 @@ export interface DeviceDef<T = unknown> {
     containers: ReadonlyMap<string, T>;
     /** 该设备在路由表里占的 path（相对根，`{page}` 由页面名替换） */
     routePath(page: string): string;
-    /** 本次访问是否属于这台设备（清单顺序 = 优先级，先命中先用） */
-    match(ctx: DeviceMatchContext): boolean;
 }
 /** 归一化外部传入的设备名；不认识的取值返回 null（**不是**落默认设备） */
 export declare function asDeviceId<T extends string>(known: readonly string[], raw: unknown): T | null;
 /** 设备 id → 中文名（调试面板用；加设备不必再改面板） */
 export declare function deviceLabel<T>(defs: readonly DeviceDef<T>[], id: string): string;
-/** 从外部输入判定「本次访问属于哪台设备」；清单顺序 = 优先级，返回值永远非空 */
-export declare function pickDeviceId<T>(defs: readonly DeviceDef<T>[], ctx: DeviceMatchContext, defaultDevice: string): string;
 /** 取某设备的容器表；未知设备返回空表（调用方退到兜底设备） */
 export declare function containersOf<T>(defs: readonly DeviceDef<T>[], id: string): ReadonlyMap<string, T>;
-/** 从当前访问信息构造判定上下文 */
-export declare function deviceContext(query: Record<string, unknown> | undefined, path: string, viewportIsMobile: boolean): DeviceMatchContext;
 //# sourceMappingURL=device.d.ts.map

package/dist/views/device.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"device.d.ts","sourceRoot":"","sources":["../../src/views/device.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,2CAA2C;AAC3C,MAAM,WAAW,kBAAkB;IACjC,qCAAqC;IACrC,cAAc,EAAE,OAAO,CAAC;IACxB,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB;IACjB,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,iDAAiD;AACjD,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,OAAO;IACpC,uCAAuC;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,sBAAsB;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qDAAqD;IACrD,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IACnC,2CAA2C;IAC3C,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAChC,qCAAqC;IACrC,KAAK,CAAC,GAAG,EAAE,kBAAkB,GAAG,OAAO,CAAC;CACzC;AAED,6CAA6C;AAC7C,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EACzC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,GAAG,EAAE,OAAO,GACX,CAAC,GAAG,IAAI,CAIV;AAED,mCAAmC;AACnC,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAEhF;AAED,6CAA6C;AAC7C,wBAAgB,YAAY,CAAC,CAAC,EAC5B,IAAI,EAAE,SAAS,SAAS,CAAC,CAAC,CAAC,EAAE,EAC7B,GAAG,EAAE,kBAAkB,EACvB,aAAa,EAAE,MAAM,GACpB,MAAM,CAMR;AAED,mCAAmC;AACnC,wBAAgB,YAAY,CAAC,CAAC,EAC5B,IAAI,EAAE,SAAS,SAAS,CAAC,CAAC,CAAC,EAAE,EAC7B,EAAE,EAAE,MAAM,GACT,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC,CAExB;AAED,qBAAqB;AACrB,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC1C,IAAI,EAAE,MAAM,EACZ,gBAAgB,EAAE,OAAO,GACxB,kBAAkB,CAUpB"}
+{"version":3,"file":"device.d.ts","sourceRoot":"","sources":["../../src/views/device.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,iDAAiD;AACjD,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,OAAO;IACpC,uCAAuC;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,sBAAsB;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qDAAqD;IACrD,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IACnC,2CAA2C;IAC3C,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;CACjC;AAED,6CAA6C;AAC7C,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EACzC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,GAAG,EAAE,OAAO,GACX,CAAC,GAAG,IAAI,CAIV;AAED,mCAAmC;AACnC,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAEhF;AAED,mCAAmC;AACnC,wBAAgB,YAAY,CAAC,CAAC,EAC5B,IAAI,EAAE,SAAS,SAAS,CAAC,CAAC,CAAC,EAAE,EAC7B,EAAE,EAAE,MAAM,GACT,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC,CAExB"}

package/dist/views/device.js

@@ -1,26 +1,30 @@
 /**
- * 设备清单机制（**纯逻辑半边**）—— 「哪些设备、怎么判定」的唯一实现（内核版）
+ * 设备清单机制（**纯逻辑半边**）—— 只描述「有哪些设备、占哪条路由、容器在哪」
  *
- * === 设备 = 路由 + 容器 = 版式信息的一部分 ===
- * 「有哪些设备」是宿主的部署事实（每个应用设备不同、容器位置不同），所以**设备清单
- * （`DeviceDef[]`）由宿主声明**；但「怎么从清单判定出当前设备、怎么归一化外部输入、
- * 怎么取容器」是**通用机制**，收在这里 —— 加一种设备时宿主只加一条声明，判定逻辑零改动。
+ * === 🔴 判定不在这里（2026-10-19 收口）===
+ * 「当前属于哪台设备」是**宿主的业务判定**，不是通用机制：
+ *   · 视口阈值（768 / 1024）、UA 兜底口径 —— 换个产品就变
+ *   · 宿主自己的 URL 词汇（`?isMobile` / `?from=mini` / `?device=` 锁定）—— 更是宿主专有
+ * 一旦下沉，库就得认识这些词汇，别的宿主复用机制时被迫沿用同一套约定；而本库对外
+ * 承诺的只有「设备域」这件机制本身。
  *
- * === 为什么这里只有「判定」、没有「组件」 ===
- * 本文件是**纯逻辑**（不含 `Component` 类型），能被内核 tsc 独立检查、也能被任何前端复用。
- * `containers` 用泛型 `T` 表达（宿主的「设备容器加载器」是 `T`），组件加载的**具体机制**
- * （`pageContainers` / `resolveContainerOf`）在 `skinsuite/vue` 的 `device-containers`，
- * 那里才 import Vue 的 `Component`。
+ * 所以判定改成**注入点**：宿主给 `app.use(theme, { router, resolveDevice })` 传一个
+ * `(ctx) => deviceId | null`，库把 router 的 `query / path / fullPath` **原样**递过去
+ * （只递事实，不带任何词汇），由宿主自己决定。库只负责：注册清单、记住当前设备、
+ * 通知订阅方、按设备取容器。
  *
- * === 判定顺序就是清单顺序（先命中先用），最后一条必须无条件成立 ===
- * 它是兜底设备。宿主关卡会核这一条。
+ * 由此「加一种设备」= 宿主加一条声明 + 一条判定分支，**库零改动**。
  *
- * === 为什么判定必须收在一处 ===
- * 三个分发器曾经各写一份「mini 来源」判定，口径不一致 → 同一个链接在不同页面落到
- * 不同设备。现在判定只有一份，各页面自然同形。
+ * === 为什么这里只有「设备」、没有「组件」 ===
+ * 本文件是**纯逻辑**（不含 `Component` 类型），能被内核 tsc 独立检查、也能被任何前端
+ * 复用。`containers` 用泛型 `T` 表达（宿主的「设备容器加载器」是 `T`），组件加载的
+ * **具体机制**（`pageContainers` / `resolveContainerOf`）在 `skinsuite/vue` 的
+ * `device-containers`，那里才 import Vue 的 `Component`。
  *
  * @author yijiu2025
  * @since 2026-10-17（从 oauth21/src/theme/devices.ts 下沉）
+ * @since 2026-10-19（判定层撤出：`match` / `DeviceMatchContext` / `pickDeviceId` /
+ *        `deviceContext` 全删，改为宿主注入 `resolveDevice`）
  */
 /** 归一化外部传入的设备名；不认识的取值返回 null（**不是**落默认设备） */
 export function asDeviceId(known, raw) {
@@ -32,28 +36,8 @@ export function asDeviceId(known, raw) {
 export function deviceLabel(defs, id) {
     return defs.find(def => def.id === id)?.label ?? id;
 }
-/** 从外部输入判定「本次访问属于哪台设备」；清单顺序 = 优先级，返回值永远非空 */
-export function pickDeviceId(defs, ctx, defaultDevice) {
-    for (const def of defs) {
-        if (def.match(ctx))
-            return def.id;
-    }
-    // 清单被改坏（末条不再无条件成立）时的保底
-    return defaultDevice;
-}
 /** 取某设备的容器表；未知设备返回空表（调用方退到兜底设备） */
 export function containersOf(defs, id) {
     return defs.find(def => def.id === id)?.containers ?? new Map();
 }
-/** 从当前访问信息构造判定上下文 */
-export function deviceContext(query, path, viewportIsMobile) {
-    const text = (key) => typeof query?.[key] === 'string' ? query[key] : '';
-    return {
-        explicitMobile: text('isMobile') === 'true',
-        path: path.split(/[?#]/)[0],
-        from: text('from'),
-        fromLogin: text('fromLogin'),
-        viewportIsMobile
-    };
-}
 //# sourceMappingURL=device.js.map

package/dist/views/device.js.map

@@ -1 +1 @@
-{"version":3,"file":"device.js","sourceRoot":"","sources":["../../src/views/device.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAgCH,6CAA6C;AAC7C,MAAM,UAAU,UAAU,CACxB,KAAwB,EACxB,GAAY;IAEZ,OAAO,OAAO,GAAG,KAAK,QAAQ,IAAK,KAA2B,CAAC,QAAQ,CAAC,GAAG,CAAC;QAC1E,CAAC,CAAE,GAAS;QACZ,CAAC,CAAC,IAAI,CAAC;AACX,CAAC;AAED,mCAAmC;AACnC,MAAM,UAAU,WAAW,CAAI,IAA6B,EAAE,EAAU;IACtE,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,IAAI,EAAE,CAAC;AACtD,CAAC;AAED,6CAA6C;AAC7C,MAAM,UAAU,YAAY,CAC1B,IAA6B,EAC7B,GAAuB,EACvB,aAAqB;IAErB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC;YAAE,OAAO,GAAG,CAAC,EAAE,CAAC;IACpC,CAAC;IACD,uBAAuB;IACvB,OAAO,aAAa,CAAC;AACvB,CAAC;AAED,mCAAmC;AACnC,MAAM,UAAU,YAAY,CAC1B,IAA6B,EAC7B,EAAU;IAEV,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,IAAI,IAAI,GAAG,EAAE,CAAC;AAClE,CAAC;AAED,qBAAqB;AACrB,MAAM,UAAU,aAAa,CAC3B,KAA0C,EAC1C,IAAY,EACZ,gBAAyB;IAEzB,MAAM,IAAI,GAAG,CAAC,GAAW,EAAU,EAAE,CACnC,OAAO,KAAK,EAAE,CAAC,GAAG,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAE,KAAK,CAAC,GAAG,CAAY,CAAC,CAAC,CAAC,EAAE,CAAC;IACjE,OAAO;QACL,cAAc,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,MAAM;QAC3C,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QAC3B,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC;QAClB,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC;QAC5B,gBAAgB;KACjB,CAAC;AACJ,CAAC"}
+{"version":3,"file":"device.js","sourceRoot":"","sources":["../../src/views/device.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAgBH,6CAA6C;AAC7C,MAAM,UAAU,UAAU,CACxB,KAAwB,EACxB,GAAY;IAEZ,OAAO,OAAO,GAAG,KAAK,QAAQ,IAAK,KAA2B,CAAC,QAAQ,CAAC,GAAG,CAAC;QAC1E,CAAC,CAAE,GAAS;QACZ,CAAC,CAAC,IAAI,CAAC;AACX,CAAC;AAED,mCAAmC;AACnC,MAAM,UAAU,WAAW,CAAI,IAA6B,EAAE,EAAU;IACtE,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,IAAI,EAAE,CAAC;AACtD,CAAC;AAED,mCAAmC;AACnC,MAAM,UAAU,YAAY,CAC1B,IAA6B,EAC7B,EAAU;IAEV,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,IAAI,IAAI,GAAG,EAAE,CAAC;AAClE,CAAC"}

package/docs/onboarding.md

@@ -17,7 +17,7 @@
 |---|---|---|
 | 多配色（明暗 + 色系，换 CSS 变量） | `skinsuite` + `skinsuite/vue` | 必选 |
 | 多版式（同一页换 DOM / 交互组织） | `skinsuite/vue` | 可选（只有一个版式就只建一个主题包） |
-| 多设备（手机 / 桌面 / 平板各自布局） | `skinsuite/vue` | 可选（单端就不声明视口 match） |
+| 多设备（手机 / 桌面 / 平板各自布局） | `skinsuite/vue` | 可选（单端就只声明一台设备） |
 | 调试面板 | `skinsuite/vue` | 可选（`theme.config.ts` 里 `debug: { enabled: 'url' }`） |
 
 **最小接入 = 多配色**：只建一个主题包、一个设备、一个页面，也能完整跑起来。
@@ -131,7 +131,7 @@ import type { Component } from 'vue';
 import { THEME_ID_RE } from 'skinsuite';
 import { defineThemeDevice } from 'skinsuite/vue';
 
-// 判定顺序 = 声明顺序，最后一条必须 fallback（兜底）
+// 声明顺序 = 优先级；**最后一条是兜底设备**（库只认顺序，不认设备名）
 defineThemeDevice({
   id: 'mobile',
   label: '手机端',
@@ -141,8 +141,7 @@ defineThemeDevice({
     fileRe: /^index\.vue$/,
     idRe: THEME_ID_RE
   },
-  routePath: page => `m/${page}`,
-  match: { explicitMobile: true, viewportMobile: true }
+  routePath: page => `m/${page}`
 });
 
 defineThemeDevice({
@@ -154,14 +153,61 @@ defineThemeDevice({
     fileRe: /^Standard/,
     idRe: THEME_ID_RE
   },
-  routePath: page => page,
-  match: { fallback: true }
+  routePath: page => page
 });
 ```
 
-`match` 里的信号是声明式的：`explicitMobile`（`?isMobile=true`）、`viewportMobile`（视口窄）、
-`from` / `fromLogin` / `pathSegment`（URL 来源标记）。`defineThemeDevice` 会自动注册进设备域、
-自动建容器表，**不要再手动写任何转发函数**。
+`defineThemeDevice` 只登记**事实**（id / label / urlKey / 容器在哪 / 占哪条路由），自动建容器表、
+自动注册进设备域，**不要再手动写任何转发函数**。
+
+🔴 **这里没有 `match`** —— 判定不归库，见 §4.1b。
+
+### 4.1b 🔴 设备判定写在哪：宿主（不是库）
+
+「当前属于哪台设备」是**业务口径**：视口阈值取 768 还是别的、UA 命中算不算、
+`?isMobile=true` / `?from=mini` / `?device=` 这些 URL 词汇，换个产品就变。
+所以库只留**注入点**，判定由宿主实现并通过 `app.use(theme, { resolveDevice })` 传进来：
+
+```ts
+// src/utils/device-resolve.ts（宿主侧）
+//
+// 🔴 别把这段放进 `src/theme/views/`：那是主题域的**纯声明目录**
+//    （defineThemePage / defineThemeDevice），会被 virtual:theme 当声明副作用 import，
+//    判定代码会跟着主题域一起进包；而且「theme/ 整包搬到另一个前端」就不成立了。
+//    theme/views/devices.ts 只留设备声明（有哪些设备、容器在哪、占哪条路由）。
+import type { DeviceDomainContext } from 'skinsuite/vue';
+import { fallbackDevice, isKnownDevice } from 'skinsuite/vue';
+import { isMobileViewport } from '@/utils/device';
+
+export function resolveCurrentDevice(ctx: DeviceDomainContext): string | null {
+  if (isKnownDevice(ctx.query.device)) return ctx.query.device as string;  // 一次性锁定
+  if (ctx.query.isMobile === 'true') return 'mobile';                     // 显式意图
+  if (ctx.query.from === 'mini') return 'mini';                           // 来源标记
+  if (isMobileViewport()) return 'mobile';                                // 视口 + UA
+  return fallbackDevice();                                                // 兜底（末条）
+}
+```
+
+`DeviceDomainContext` 只给**事实** —— `{ query, path, fullPath }`，没有任何词汇。
+库不认识「手机」是什么、也不认识 768 这个数。
+
+**视口变化怎么办**：库不订阅 `matchMedia`（「什么算变了」也是宿主口径）。
+宿主自己订阅，然后叫库重判：
+
+```ts
+import { refreshDevice } from 'skinsuite/vue';
+import { watchViewport } from '@/utils/device';
+
+watchViewport(() => refreshDevice());
+```
+
+**加一种设备**要动的四处：`theme/views/devices.ts` 一条 `defineThemeDevice` 声明 /
+`utils/device-resolve.ts` 一条判定分支 / 容器组件 / 主题包里加设备目录。库零改动。
+
+⚠️ 判定函数依赖「设备域已注册的清单」（`isKnownDevice` / `fallbackDevice`），
+所以 `bootstrap.ts` 要在 `app.use(theme)` **之前** import 一次声明模块
+（`import './theme/views/devices'`）—— 通常 `virtual:theme` 会拉齐，但显式 import
+能让顺序确定，不依赖插件产物。
 
 ### 4.2 页面契约 `views/<page>.ts`
 
@@ -272,21 +318,22 @@ app.use(createPinia());
 app.use(router);
 app.use(i18n);
 
-// 设备域启动：传 router + 宿主自己的「设备覆盖」解析。
+// 设备域启动：传 router + 宿主自己的判定函数。
 // 库只认 router 的最小结构（currentRoute.value.{ query, path, fullPath }），
-// 不 import vue-router，不写死任何 URL 词汇。
-app.use(theme, {
-  router,
-  // ?device=<id> 是宿主自己的 URL 约定，用注入点交给库（返回 null = 不覆盖）
-  resolveDeviceOverride: query => (typeof query.device === 'string' ? query.device : null)
-});
+// 不 import vue-router，**也不认识任何 URL 词汇或视口阈值** —— 判定全在
+// `theme/views/devices.ts` 的 resolveCurrentDevice 里（含 ?device= 锁定）。
+app.use(theme, { router, resolveDevice: resolveCurrentDevice });
+
+// 视口变化 → 让设备域重判（库不订阅 matchMedia）
+watchViewport(() => refreshDevice());
 
 router.isReady().then(() => app.mount('#app'));
 ```
 
-**`resolveDeviceOverride` 的语义**：宿主想让「某个 URL 参数能锁定设备（压过视口自动判定）」
-时，通过它注入解析逻辑。参数名（`device`）是宿主词汇，库不认识也不写死；返回合法设备 id
-即锁定、返回 `null` 或非法 id 走自动判定。**不需要这个能力就不传，字段可选。**
+**`resolveDevice` 的语义**：`(ctx) => deviceId | null`，**唯一的判定入口**。`ctx` 只有
+`{ query, path, fullPath }` 三个事实字段。返回合法设备 id 即采用；返回 `null` 或未知 id
+走兜底设备（清单末条）。宿主在里面怎么写都行 —— `?device=` 锁定、`?isMobile`、UA、视口，
+都是宿主自己的事。**不传就全部落兜底设备**（单端应用可以只用一句话的判定了）。
 
 ---
 
@@ -417,7 +464,7 @@ const ctx = computed<LoginViewContext>(() => ({
 | 构建 | `vite build` | 成功，内置包 eager、非内置包独立 chunk |
 | 手测 | `?th=<包>` / `?th_<设备缩写>=<包>` | 版式切换 |
 | 手测 | `?debug=theme` | 调试面板出现，可切配色 |
-| 手测 | 缩放窗口 / 换 UA | 手机 / 桌面自动切换（若声明了视口 match） |
+| 手测 | 缩放窗口 / 换 UA | 手机 / 桌面自动切换（由宿主的 `resolveDevice` 决定） |
 | 手测 | `?device=mobile`（若注入 override） | 锁定手机端，刷新后失效 |
 
 ---
@@ -439,8 +486,10 @@ const ctx = computed<LoginViewContext>(() => ({
 5. **在容器里手写 `setActiveDevice` / `setActivePageView`** → 冗余且会被 `<ThemeView>` 覆盖。
    全删，交给 `<ThemeView>`。
 
-6. **URL 词汇（`?device=` 等）写进库里** → 边界错。库只提供通用注入点（`resolveDeviceOverride`），
-   参数名是宿主词汇，只写在宿主装配处。
+6. **设备判定（视口阈值 / UA / `?device=` / `?isMobile` / `?from=`）写进库里** → 边界错。
+   库只提供注入点 `resolveDevice`（`ctx` 里只有 `query / path / fullPath` 三个事实），
+   判定与它的词汇全部写在宿主（见 §4.1b）。同理别指望库订阅 `matchMedia` ——
+   视口变化由宿主订阅后调 `refreshDevice()`。
 
 7. **容器摊平在 `view/web/` 下**（`web/StandardLogin.vue`）→ 页面名被算成 `web`，该页在这一设备上
    等于「没写容器」。`standard` / `mini` 必须各自待在 `view/web/<页面>/` 里，见 §9.2。
@@ -456,7 +505,7 @@ my-app/
 ├── vite.config.ts            # themeAssets({ dir: resolveThemeDir(mode) }) + vue()
 ├── .env                      # VITE_THEME_DIR=src/theme（可省）
 └── src/
-    ├── bootstrap.ts          # app.use(theme, { router, resolveDeviceOverride? })
+    ├── bootstrap.ts          # app.use(theme, { router, resolveDevice }) + watchViewport(refreshDevice)
     ├── App.vue               # <ThemeRoot :theme-store> + <ThemeDebugPanel>
     ├── stores/theme.ts       # defineStore('theme', () => createThemeState()) + import 'virtual:theme'
     ├── router/index.ts       # 固定声明 /<page>、/m/<page>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skinsuite",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "多主题 / 多版式机制的纯内核（零运行时依赖）：目录名与默认值的白名单常量、主题包契约类型、明暗 mode 与色系 tone、CSS 变量 token 的安全校验、设备维度 URL 参数读取。不碰 DOM / 构建器 / 路由，可在任意前端（Vue / React / Node / SSR）复用。",
   "type": "module",
   "main": "./dist/index.js",
@@ -75,6 +75,8 @@
     }
   },
   "devDependencies": {
-    "typescript": "^6.0.3"
+    "@types/node": "^22.0.0",
+    "typescript": "^6.0.3",
+    "vite": "^7.0.0"
   }
 }

package/src/index.ts

@@ -83,21 +83,14 @@ export {
 export { DEVICE_SCOPED_PARAMS, readDeviceParam } from './views/params.js';
 export type { DeviceScopedParam } from './views/params.js';
 
-export {
-  asDeviceId,
-  containersOf,
-  deviceContext,
-  deviceLabel,
-  pickDeviceId
-} from './views/device.js';
-export type { DeviceDef, DeviceMatchContext } from './views/device.js';
-
 /**
- * 设备注册表工厂：一份 `DeviceDef[]` 清单 → 全套已绑定的判定机制。
- * 宿主不再逐个转发判定函数，只写清单、调一次工厂。
+ * 设备清单机制（只有事实与查询，**判定不在这里**）
+ *
+ * 「当前属于哪台设备」由宿主注入 `resolveDevice`（`skinsuite/vue`），库不认识
+ * 视口阈值 / UA / `?isMobile` / `?from=` 这些词汇。
  */
-export { createDeviceRegistry } from './views/device-registry.js';
-export type { DeviceRegistry, DeviceRegistryOptions } from './views/device-registry.js';
+export { asDeviceId, containersOf, deviceLabel } from './views/device.js';
+export type { DeviceDef } from './views/device.js';
 
 /**
  * 外部下发的主题配置：**只归一形状，不碰网络**

package/src/views/device.ts

@@ -1,42 +1,32 @@
 /**
- * 设备清单机制（**纯逻辑半边**）—— 「哪些设备、怎么判定」的唯一实现（内核版）
+ * 设备清单机制（**纯逻辑半边**）—— 只描述「有哪些设备、占哪条路由、容器在哪」
  *
- * === 设备 = 路由 + 容器 = 版式信息的一部分 ===
- * 「有哪些设备」是宿主的部署事实（每个应用设备不同、容器位置不同），所以**设备清单
- * （`DeviceDef[]`）由宿主声明**；但「怎么从清单判定出当前设备、怎么归一化外部输入、
- * 怎么取容器」是**通用机制**，收在这里 —— 加一种设备时宿主只加一条声明，判定逻辑零改动。
+ * === 🔴 判定不在这里（2026-10-19 收口）===
+ * 「当前属于哪台设备」是**宿主的业务判定**，不是通用机制：
+ *   · 视口阈值（768 / 1024）、UA 兜底口径 —— 换个产品就变
+ *   · 宿主自己的 URL 词汇（`?isMobile` / `?from=mini` / `?device=` 锁定）—— 更是宿主专有
+ * 一旦下沉，库就得认识这些词汇，别的宿主复用机制时被迫沿用同一套约定；而本库对外
+ * 承诺的只有「设备域」这件机制本身。
  *
- * === 为什么这里只有「判定」、没有「组件」 ===
- * 本文件是**纯逻辑**（不含 `Component` 类型），能被内核 tsc 独立检查、也能被任何前端复用。
- * `containers` 用泛型 `T` 表达（宿主的「设备容器加载器」是 `T`），组件加载的**具体机制**
- * （`pageContainers` / `resolveContainerOf`）在 `skinsuite/vue` 的 `device-containers`，
- * 那里才 import Vue 的 `Component`。
+ * 所以判定改成**注入点**：宿主给 `app.use(theme, { router, resolveDevice })` 传一个
+ * `(ctx) => deviceId | null`，库把 router 的 `query / path / fullPath` **原样**递过去
+ * （只递事实，不带任何词汇），由宿主自己决定。库只负责：注册清单、记住当前设备、
+ * 通知订阅方、按设备取容器。
  *
- * === 判定顺序就是清单顺序（先命中先用），最后一条必须无条件成立 ===
- * 它是兜底设备。宿主关卡会核这一条。
+ * 由此「加一种设备」= 宿主加一条声明 + 一条判定分支，**库零改动**。
  *
- * === 为什么判定必须收在一处 ===
- * 三个分发器曾经各写一份「mini 来源」判定，口径不一致 → 同一个链接在不同页面落到
- * 不同设备。现在判定只有一份，各页面自然同形。
+ * === 为什么这里只有「设备」、没有「组件」 ===
+ * 本文件是**纯逻辑**（不含 `Component` 类型），能被内核 tsc 独立检查、也能被任何前端
+ * 复用。`containers` 用泛型 `T` 表达（宿主的「设备容器加载器」是 `T`），组件加载的
+ * **具体机制**（`pageContainers` / `resolveContainerOf`）在 `skinsuite/vue` 的
+ * `device-containers`，那里才 import Vue 的 `Component`。
  *
  * @author yijiu2025
  * @since 2026-10-17（从 oauth21/src/theme/devices.ts 下沉）
+ * @since 2026-10-19（判定层撤出：`match` / `DeviceMatchContext` / `pickDeviceId` /
+ *        `deviceContext` 全删，改为宿主注入 `resolveDevice`）
  */
 
-/** 判定上下文 —— 判定所需的**全部**外部信息（与页面无关的原始事实） */
-export interface DeviceMatchContext {
-  /** `?isMobile=true` —— 显式意图，优先级最高 */
-  explicitMobile: boolean;
-  /** 路由 path（不含 query / hash） */
-  path: string;
-  /** `?from=` 的取值（iframe 来源标记，空串表示没给） */
-  from: string;
-  /** `?fromLogin=` 的取值（历史键：从 mini 登录页跳来） */
-  fromLogin: string;
-  /** 视口/UA 判定结果 */
-  viewportIsMobile: boolean;
-}
-
 /** 一条设备声明（`containers` 是泛型：纯逻辑侧不关心它到底是什么，只透传） */
 export interface DeviceDef<T = unknown> {
   /** 设备 id = 主题包内的目录名，只允许 `[a-z0-9-]` */
@@ -49,8 +39,6 @@ export interface DeviceDef<T = unknown> {
   containers: ReadonlyMap<string, T>;
   /** 该设备在路由表里占的 path（相对根，`{page}` 由页面名替换） */
   routePath(page: string): string;
-  /** 本次访问是否属于这台设备（清单顺序 = 优先级，先命中先用） */
-  match(ctx: DeviceMatchContext): boolean;
 }
 
 /** 归一化外部传入的设备名；不认识的取值返回 null（**不是**落默认设备） */
@@ -68,19 +56,6 @@ export function deviceLabel<T>(defs: readonly DeviceDef<T>[], id: string): strin
   return defs.find(def => def.id === id)?.label ?? id;
 }
 
-/** 从外部输入判定「本次访问属于哪台设备」；清单顺序 = 优先级，返回值永远非空 */
-export function pickDeviceId<T>(
-  defs: readonly DeviceDef<T>[],
-  ctx: DeviceMatchContext,
-  defaultDevice: string
-): string {
-  for (const def of defs) {
-    if (def.match(ctx)) return def.id;
-  }
-  // 清单被改坏（末条不再无条件成立）时的保底
-  return defaultDevice;
-}
-
 /** 取某设备的容器表；未知设备返回空表（调用方退到兜底设备） */
 export function containersOf<T>(
   defs: readonly DeviceDef<T>[],
@@ -88,20 +63,3 @@ export function containersOf<T>(
 ): ReadonlyMap<string, T> {
   return defs.find(def => def.id === id)?.containers ?? new Map();
 }
-
-/** 从当前访问信息构造判定上下文 */
-export function deviceContext(
-  query: Record<string, unknown> | undefined,
-  path: string,
-  viewportIsMobile: boolean
-): DeviceMatchContext {
-  const text = (key: string): string =>
-    typeof query?.[key] === 'string' ? (query[key] as string) : '';
-  return {
-    explicitMobile: text('isMobile') === 'true',
-    path: path.split(/[?#]/)[0],
-    from: text('from'),
-    fromLogin: text('fromLogin'),
-    viewportIsMobile
-  };
-}

package/src/vue/define-theme-device.ts

@@ -1,41 +1,30 @@
 /**
  * 设备声明工厂 —— `defineThemeDevice`（声明式，自动注册进设备域）
  *
- * 宿主只写一条声明（`id` / `label` / `urlKey` / `containers` 三参数 / `routePath` /
- * 声明式 `match`），机制全在库内：`pageContainers` 建容器表、声明式 `match` → 判定函数、
- * 自动注册进设备域。宿主不再写 `createDeviceRegistry` 装配、不再手动组数组、不再转发
- * `asKnownDevice`。
+ * 宿主只写一条声明（`id` / `label` / `urlKey` / `containers` 三参数 / `routePath`），
+ * 机制全在库内：`pageContainers` 建容器表、按声明顺序注册进设备域。宿主不再写
+ * `createDeviceRegistry` 装配、不再手动组数组、不再转发 `asKnownDevice`。
  *
- * === 声明式 match 的优先级规则（库内唯一实现）===
- * 字段间 OR；`explicitMobile` 是**全局最高优先信号** —— 一旦 `ctx.explicitMobile=true`，
- * 带 `from`/`fromLogin`/`pathSegment` 的条目直接跳过，落到 `explicitMobile: true` 的条目
- * （mobile）。宿主不再手写「排除显式手机意图」的 `!explicitMobile`。
+ * === 🔴 这里没有 `match`（2026-10-19 收口）===
+ * 早先这里带一个「声明式 match」（`explicitMobile` / `from` / `fromLogin` /
+ * `pathSegment` / `viewportMobile` / `fallback`），并由库解释成判定函数 ——
+ * 那等于把**宿主的判定词汇**（`?isMobile`、`?from=mini`、视口阈值）写进了库。
+ * 现在判定归宿主：`app.use(theme, { resolveDevice })` 传一个函数，库把 router 的
+ * `query / path / fullPath` 原样递过去。声明里只剩「这台设备叫什么、容器在哪」。
+ *
+ * === 声明顺序 = 优先级，末条是兜底 ===
+ * `fallbackDevice()` 取末条、`resolveContainerOf()` 兜底也走末条 —— 库不认识
+ * `standard` 这类具体名字，只认顺序。所以**末条必须是兜底设备**（宿主关卡盯着）。
  *
  * @author yijiu2025
  * @since 2026-10-18（从 oauth21/src/theme/views/devices.ts 的声明下沉）
+ * @since 2026-10-19（`match` 撤出，判定改由宿主注入 `resolveDevice`）
  */
-import { pickDeviceId as pickDeviceIdOf } from '../views/device';
-import type { DeviceDef, DeviceMatchContext } from '../views/device';
+import type { DeviceDef } from '../views/device';
 import { pageContainers, resolveContainerOf as resolveContainerOfWith } from './device-containers';
 import type { DeviceContainerLoader } from './device-containers';
 
-/** 声明式 match：字段间 OR；`fallback` 与其它互斥 */
-export interface DeclarativeMatch {
-  /** `?isMobile=true` 显式手机意图（全局最高优先信号） */
-  explicitMobile?: boolean;
-  /** 视口/UA 判为手机 */
-  viewportMobile?: boolean;
-  /** `?from=` 命中任一值 */
-  from?: string[];
-  /** `?fromLogin=` 命中任一值 */
-  fromLogin?: string[];
-  /** 路径含某整段/前缀 */
-  pathSegment?: string;
-  /** 兜底（无条件命中；必须是清单末条） */
-  fallback?: boolean;
-}
-
-/** `defineThemeDevice` 的输入（声明式） */
+/** `defineThemeDevice` 的输入（只描述设备事实，不含任何判定） */
 export interface ThemeDeviceOptions {
   /** 设备 id = 主题包内目录名，只允许 `[a-z0-9-]` */
   id: string;
@@ -54,46 +43,16 @@ export interface ThemeDeviceOptions {
   };
   /** 该设备在路由表占的 path（`{page}` 由页面名替换） */
   routePath(page: string): string;
-  /** 声明式 match（不再手写闭包） */
-  match: DeclarativeMatch;
 }
 
-/** 路径是否含某整段/前缀（`mini` 匹配 `/mini/login` 或旧 `mini-login`） */
-function pathHasDeviceSegment(path: string, prefix: string): boolean {
-  return path
-    .split('/')
-    .filter(Boolean)
-    .some(seg => seg === prefix || seg.startsWith(`${prefix}-`));
-}
-
-/**
- * 声明式 match → 判定函数
- *
- * 字段间 OR；`explicitMobile` 是全局最高优先信号。
- */
-function normalizeMatch(m: DeclarativeMatch): (ctx: DeviceMatchContext) => boolean {
-  if (m.fallback) return () => true;
-  return (ctx: DeviceMatchContext) => {
-    // 显式手机意图下，带 from/fromLogin/pathSegment 的条目跳过（落到 explicitMobile 条目）
-    if (ctx.explicitMobile && (m.from || m.fromLogin || m.pathSegment)) return false;
-    return (
-      (m.explicitMobile === true && ctx.explicitMobile) ||
-      (m.viewportMobile === true && ctx.viewportIsMobile) ||
-      (m.from !== undefined && m.from.includes(ctx.from)) ||
-      (m.fromLogin !== undefined && m.fromLogin.includes(ctx.fromLogin)) ||
-      (m.pathSegment !== undefined && pathHasDeviceSegment(ctx.path, m.pathSegment))
-    );
-  };
-}
-
-/** 已自动注册的设备清单（顺序 = 优先级，末条必须 fallback 兜底） */
+/** 已自动注册的设备清单（顺序 = 优先级，末条是兜底设备） */
 const registeredDefs: DeviceDef<DeviceContainerLoader>[] = [];
 
 /**
  * 声明一台设备并自动注册进设备域
  *
- * 内部做三件事：`pageContainers(glob, fileRe, idRe)` 建容器表、声明式 `match` → 判定函数、
- * 注册进设备域。
+ * 内部只做两件事：`pageContainers(glob, fileRe, idRe)` 建容器表、按声明顺序注册。
+ * 「怎么判定当前是哪台设备」不在这里 —— 由宿主 `resolveDevice` 负责。
  */
 export function defineThemeDevice(options: ThemeDeviceOptions): DeviceDef<DeviceContainerLoader> {
   const def: DeviceDef<DeviceContainerLoader> = {
@@ -105,8 +64,7 @@ export function defineThemeDevice(options: ThemeDeviceOptions): DeviceDef<Device
       options.containers.fileRe,
       options.containers.idRe
     ),
-    routePath: options.routePath,
-    match: normalizeMatch(options.match)
+    routePath: options.routePath
   };
   registeredDefs.push(def);
   return def;
@@ -136,17 +94,12 @@ export function deviceIds(): string[] {
   return registeredDefs.map(d => d.id);
 }
 
-/** 兜底设备 = 末条 fallback 声明的 id（顺序即优先级，末条必须 fallback）；未声明设备时返回空串 */
+/** 兜底设备 = 末条声明的 id（声明顺序即优先级）；未声明设备时返回空串 */
 export function fallbackDevice(): string {
   return registeredDefs[registeredDefs.length - 1]?.id ?? '';
 }
 
-/** 从外部输入判定「本次访问属于哪台设备」（用设备域单例 + 兜底设备） */
-export function pickDeviceId(ctx: DeviceMatchContext): string {
-  return pickDeviceIdOf(registeredDefs, ctx, fallbackDevice());
-}
-
-/** 取某设备在某页的容器加载器，**没写时兜底到 standard 设备**（用设备域单例） */
+/** 取某设备在某页的容器加载器，**没写时兜底到末条设备**（用设备域单例） */
 export function resolveContainerOf(id: string, page: string): DeviceContainerLoader {
   return resolveContainerOfWith(registeredDefs, id, page);
 }

package/src/vue/device-containers.ts

@@ -52,22 +52,26 @@ export function containerOf(
 }
 
 /**
- * 取某设备在某页的容器加载器，**没写时兜底到 standard 设备**
+ * 取某设备在某页的容器加载器，**没写时兜底到末条设备**（声明顺序即优先级）
  *
  * 分发器用它做「设备 id → 该页容器」的数据化映射：加一种设备时，只要给它写了容器，
- * 分发器就能渲染；没写则该设备退到桌面容器 —— 不再写死「mobile ? X : mini ? Y : Standard」。
+ * 分发器就能渲染；没写则该设备退到兜底设备 —— 不再写死「mobile ? X : mini ? Y : Standard」。
+ *
+ * 🔴 兜底目标取**末条声明**，不写死 `'standard'`（2026-10-19）：具体设备名是宿主的词汇，
+ *    库只认「声明顺序，末条兜底」这条机制。宿主把兜底设备放末条即可。
  */
 export function resolveContainerOf(
   defs: readonly DeviceDef<DeviceContainerLoader>[],
   id: string,
   page: string
 ): DeviceContainerLoader {
+  const fallback = defs[defs.length - 1]?.id;
   return (
     containerOf(defs, id, page) ??
-    containerOf(defs, 'standard', page) ??
+    (fallback === undefined ? undefined : containerOf(defs, fallback, page)) ??
     (() =>
       Promise.reject(
-        new Error(`[theme] 设备「${id}」在页面「${page}」没有容器，也没有 standard 兜底`)
+        new Error(`[theme] 设备「${id}」在页面「${page}」没有容器，也没有兜底设备`)
       ))
   );
 }

package/src/vue/device-domain.ts

@@ -1,25 +1,29 @@
 /**
- * 设备域运行时 —— 当前生效设备 `activeDevice` + matchMedia 视口判定 + 路由监听 → 判定
+ * 设备域运行时 —— 维护「当前生效设备」这一状态，判定交给宿主
  *
- * 与 `define-theme-device`（声明工厂）配对：宿主在 `defineThemeDevice` 里声明设备清单
- * （自动注册），本文件维护「当前属于哪台设备」这一运行时状态，供宿主 store 订阅、供
- * token 注入 / 版式查找取用。
+ * 与 `define-theme-device`（声明工厂）配对：宿主声明设备清单（自动注册），本文件维护
+ * 「当前属于哪台设备」，供宿主 store 订阅、供 token 注入 / 版式查找取用。
  *
- * === 信号来源 ===
- * 设备判定只有「设备清单 `match`」一个来源，输入是 path / query（从 router 拿）+ 视口
- * （`matchMedia`，阈值可配）。**不再有 `meta.device`** 这个冗余基线。
+ * === 🔴 判定归宿主（2026-10-19 收口）===
+ * 本文件**不认识**视口阈值、UA、`?isMobile`、`?from=mini`、`?device=` 这些词汇 ——
+ * 它们都是宿主的产品约定。库只把 router 上的事实（`query / path / fullPath`）原样
+ * 交给宿主注入的 `resolveDevice`，拿回一个设备 id；不合法/返回 null 就落到兜底设备
+ * （清单末条）。
+ *
+ * 宿主自己知道「什么时候该重判」（视口变了、UA 变了、自己的开关变了），所以本文件
+ * 额外暴露 `refreshDevice()` 让宿主主动触发 —— 库**不订阅** `matchMedia`，也就不会
+ * 和宿主的响应式口径打架。
  *
  * === 为什么库只认 router 的最小结构 ===
  * 库不 import vue-router（应用世界观），只认 `currentRoute.value.{ query, path, fullPath }`
- * 这三个字段 —— 宿主把 router 传进来（`app.use(theme, { router })`）。
+ * 这三个字段 —— 宿主把 router 传进来（`app.use(theme, { router, resolveDevice })`）。
  *
  * @author yijiu2025
  * @since 2026-10-18
+ * @since 2026-10-19（`matchMedia` / 视口 / `resolveDeviceOverride` 撤出，改 `resolveDevice` + `refreshDevice`）
  */
 import { ref, watch } from 'vue';
-import { deviceContext, pickDeviceId } from '../views/device';
 import { registeredDevices } from './define-theme-device';
-import { DESKTOP_MIN_WIDTH, MOBILE_BREAKPOINT, detectMobileUA } from './viewport';
 
 /** 路由的最小结构（库不 import vue-router，只认这些字段） */
 export interface DeviceDomainRouter {
@@ -34,75 +38,63 @@ export interface DeviceDomainRouter {
   replace?(to: { query: Record<string, string | string[] | undefined> }): unknown;
 }
 
+/**
+ * 交给宿主的**判定输入** —— 只有事实，没有任何词汇
+ *
+ * 宿主在这里自己决定：视口宽窄、UA、`?isMobile`、`?from=mini`、`?device=` 锁定……
+ * 都是宿主的事；库不参与、也不缓存这些概念。
+ */
+export interface DeviceDomainContext {
+  /** 当前路由 query */
+  query: Record<string, unknown>;
+  /** 路由 path（不含 query / hash） */
+  path: string;
+  /** 完整路径（宿主可用于自己的来源判断） */
+  fullPath: string;
+}
+
 export interface InstallThemeDomainOptions {
   router: DeviceDomainRouter;
   /**
-   * 宿主注入的「设备覆盖」解析：从当前 query 返回要**锁定**的设备 id，`null` = 不覆盖。
+   * 宿主判定「本次访问属于哪台设备」：返回设备 id，`null` = 交给兜底设备。
    *
-   * 用于宿主自己的 URL 约定（如 `?device=mobile` 锁定手机端）——参数名是宿主词汇，
-   * 库不认、也不写死，只提供一个「显式覆盖自动判定」的通用注入点。命中合法设备时
-   * 优先于 `?isMobile` / `?from` / 视口；返回 null 或非法 id 则走自动判定。
+   * 返回未知 id 时按 `null` 处理（不信任宿主手滑写错的名字）。
+   * 🔴 这是**唯一的判定入口** —— 库内没有任何默认判定实现。
    */
-  resolveDeviceOverride?: (query: Record<string, unknown>) => string | null;
+  resolveDevice?: (ctx: DeviceDomainContext) => string | null;
 }
 
 /** 当前生效设备（响应式；宿主 store 从这里订阅） */
 const activeDevice = ref<string>('');
 
-/** 视口是否判为手机（响应式；「1024 优先 + 768 窄 + UA 兜底」口径，见 viewport.ts） */
-const viewportMobile = ref(false);
-
 let routerRef: DeviceDomainRouter | null = null;
-let resolveDeviceOverride: InstallThemeDomainOptions['resolveDeviceOverride'] = undefined;
+let resolveDevice: InstallThemeDomainOptions['resolveDevice'];
 
-/** 判定一次设备并写入 activeDevice */
+/**
+ * 判定一次设备并写入 `activeDevice`
+ *
+ * 优先宿主 `resolveDevice` 的结果；返回 null / 未知 id → 清单末条（兜底设备）。
+ */
 function judgeDevice(): void {
   const defs = registeredDevices();
   if (!routerRef || defs.length === 0) return;
   const route = routerRef.currentRoute.value;
 
-  // 宿主注入的设备覆盖（如 ?device=）：命中合法设备直接锁定，压过自动判定
-  const override = resolveDeviceOverride?.(route.query) ?? null;
-  if (override && defs.some(d => d.id === override)) {
-    if (activeDevice.value !== override) activeDevice.value = override;
-    return;
-  }
-
-  const ctx = deviceContext(route.query, route.path, viewportMobile.value);
-  // 兜底 = 末条 fallback 设备的 id（默认设备的指定先不在这里定）
-  const fallback = defs[defs.length - 1].id;
-  const next = pickDeviceId(defs, ctx, fallback);
+  const picked = resolveDevice?.({ query: route.query, path: route.path, fullPath: route.fullPath });
+  const known = picked !== null && picked !== undefined && defs.some(d => d.id === picked);
+  const next = known ? (picked as string) : defs[defs.length - 1].id;
   if (activeDevice.value !== next) activeDevice.value = next;
 }
 
 /**
- * 装配设备域运行时（`app.use(theme, { router })` 时调用一次）
+ * 装配设备域运行时（`app.use(theme, { router, resolveDevice })` 时调用一次）
  *
- * 建立两条响应链：链接变动（`fullPath`）→ 判定；视口变化（两个 matchMedia + UA）→ 判定。
- * 视口口径与宿主 `useDeviceDetect` 一致（宽视口优先 + 窄视口 + UA 兜底），保证设备域
- * 判出的 `currentDevice` 与分发器渲染的形态同源。
+ * 只建一条响应链：路由 `fullPath` 变动 → 判定。
+ * 视口 / UA / 宿主其它信号变化时，宿主自己调 `refreshDevice()`。
  */
 export function installThemeDomain(options: InstallThemeDomainOptions): void {
   routerRef = options.router;
-  resolveDeviceOverride = options.resolveDeviceOverride;
-
-  if (typeof window !== 'undefined' && typeof window.matchMedia === 'function') {
-    const desktopMq = window.matchMedia(`(min-width: ${DESKTOP_MIN_WIDTH}px)`);
-    const mobileMq = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);
-    const syncViewport = (): void => {
-      // 宽视口优先：放得下桌面布局就一律电脑版，UA 说什么都不例外
-      if (desktopMq.matches || window.innerWidth >= DESKTOP_MIN_WIDTH) {
-        viewportMobile.value = false;
-        return;
-      }
-      // 窄视口直接移动端；中间段（768–1023）交给 UA 兜底（该区间可能是被缩放的桌面浏览器）
-      const narrow = mobileMq.matches || window.innerWidth < MOBILE_BREAKPOINT;
-      viewportMobile.value = narrow ? true : detectMobileUA();
-    };
-    syncViewport();
-    desktopMq.addEventListener('change', syncViewport);
-    mobileMq.addEventListener('change', syncViewport);
-  }
+  resolveDevice = options.resolveDevice;
 
   // 🔴 watch fullPath 而非整个路由对象：同路由 query/hash 变化不触发重判
   watch(
@@ -110,9 +102,15 @@ export function installThemeDomain(options: InstallThemeDomainOptions): void {
     () => judgeDevice(),
     { immediate: true }
   );
+}
 
-  // 视口变化 → 重判
-  watch(viewportMobile, () => judgeDevice());
+/**
+ * 让宿主在**自己的信号变化时**主动重判（视口、UA、自己存的开关……）
+ *
+ * 幂等、廉价；未装配 router 时是空操作。
+ */
+export function refreshDevice(): void {
+  judgeDevice();
 }
 
 /** 当前生效设备（只读响应式，宿主 store 订阅它） */

package/src/vue/index.ts

@@ -56,26 +56,30 @@ export {
   deviceIds,
   fallbackDevice,
   isKnownDevice,
-  pickDeviceId,
   registeredDevices,
   resetDevices,
   resolveContainerOf,
   urlKeyOf
 } from './define-theme-device';
-export type { DeclarativeMatch, ThemeDeviceOptions } from './define-theme-device';
-export { currentDevice, currentQuery, installThemeDomain, replaceQuery } from './device-domain';
-export type { DeviceDomainRouter, InstallThemeDomainOptions } from './device-domain';
+export type { ThemeDeviceOptions } from './define-theme-device';
+export {
+  currentDevice,
+  currentQuery,
+  installThemeDomain,
+  refreshDevice,
+  replaceQuery
+} from './device-domain';
+export type {
+  DeviceDomainContext,
+  DeviceDomainRouter,
+  InstallThemeDomainOptions
+} from './device-domain';
 export { theme } from './plugin';
 export type { ThemePluginOptions } from './plugin';
 
-// ---- 视口 / UA 设备形态判定（2026-10-19 下沉，供设备域与宿主守卫/请求共用）----
-export {
-  DESKTOP_MIN_WIDTH,
-  MOBILE_BREAKPOINT,
-  detectMobileUA,
-  isDesktopViewport,
-  isMobileViewport
-} from './viewport';
+// ── 视口 / UA 判定**不在这里**（2026-10-19 收口）──────────────────────────────
+// 「手机还是电脑」是宿主的业务口径（768 / 1024 阈值、UA 兜底、`?isMobile` 等），
+// 换个产品就变。库只提供注入点 `resolveDevice`（见 device-domain），宿主自己判定。
 
 // ---- 主题状态机（scope/intent/runtime + 持久化，2026-10-19 下沉）----
 // 🔴 只导出 `createThemeState`（编排入口）—— scope/intent/runtime/persistence 是内部实现，

package/src/vue/plugin.ts

@@ -20,16 +20,22 @@ import type { DeviceDomainRouter, InstallThemeDomainOptions } from './device-dom
 export interface ThemePluginOptions {
   /** 宿主路由（库只认 `currentRoute.value.{ query, path, fullPath }` 最小结构） */
   router: DeviceDomainRouter;
-  /** 宿主注入的设备覆盖解析（`?device=` 等宿主 URL 词汇），透传给设备域 */
-  resolveDeviceOverride?: InstallThemeDomainOptions['resolveDeviceOverride'];
+  /**
+   * 宿主判定「当前属于哪台设备」—— **唯一的判定入口**。
+   *
+   * 库把 `{ query, path, fullPath }` 原样递过去，宿主自己用视口 / UA / 自己的 URL 词汇
+   * （`?isMobile`、`?from=mini`、`?device=` 锁定……）决定返回哪个设备 id；返回 `null`
+   * 走兜底设备（清单末条）。
+   */
+  resolveDevice?: InstallThemeDomainOptions['resolveDevice'];
 }
 
-/** Vue 插件：`app.use(theme, { router, resolveDeviceOverride? })` */
+/** Vue 插件：`app.use(theme, { router, resolveDevice })` */
 export const theme: Plugin<[ThemePluginOptions]> = {
   install(_app: App, options: ThemePluginOptions) {
     installThemeDomain({
       router: options.router,
-      resolveDeviceOverride: options.resolveDeviceOverride
+      resolveDevice: options.resolveDevice
     });
   }
 };

package/src/vue/theme-scope.ts

@@ -62,7 +62,8 @@ export function useThemeScope(keys: ThemeStorageKeys, colorParam: string) {
 
   /**
    * 从**设备域**订阅当前生效设备（设备判定已收进库内设备域，这里只读）。
-   * `app.use(theme, { router })` 里设备域监听路由 + 视口 → `pickDeviceId` 判定 → `activeDevice`，
+   * `app.use(theme, { router, resolveDevice })` 里设备域监听路由 + 宿主主动
+   * `refreshDevice()` → 宿主 `resolveDevice` 判定 → `activeDevice`，
    * 这里把它同步进作用域（`immediate` 覆盖 store 实例化时设备域已判好的值）。
    */
   watch(

package/src/views/device-registry.ts

@@ -1,96 +0,0 @@
-/**
- * 设备注册表工厂 —— 「一份设备清单 → 全套判定机制」的**唯一实现**（内核版）
- *
- * === 为什么要有它 ===
- * 宿主（oauth21 等）曾经在 `views/devices.ts` 里既要写清单（`DeviceDef[]`），又要逐个
- * re-export 内核的判定函数（`deviceLabel` / `pickDeviceId` / `containersOf` / …），
- * 每个新项目都要把这一串转发函数抄一遍 —— 那是纯样板。本工厂把「清单 → 机制」收成
- * 一步：宿主只写一份 `DeviceDef[]`，调一次 `createDeviceRegistry(defs)`，全套判定函数
- * 就位，且都绑定了这份清单、参数顺序按宿主直觉收敛（不再要求每个调用点传 defs）。
- *
- * === 与 `views/device.ts` 的关系 ===
- * `device.ts` 是**无状态纯函数**（`pickDeviceId(defs, ctx, …)` 每次传清单），供内核
- * 内部与「清单还没装进注册表」的场景用；本文件是它的**装配层**——把清单闭包进去，
- * 产出「已绑定清单」的面向宿主的 API。组件半边（`containerOf` / `resolveContainerOf`）
- * 住在 `skinsuite/vue` 的 `device-containers.ts`，本文件的工厂也收那一半。
- *
- * === 为什么设备是宽 `string` + 白名单参数 ===
- * 内核不认识宿主的设备词汇表（哪些目录名算合法设备是宿主的部署事实），所以：
- *   · 判定函数对外都收 `string`、返回 `string`；
- *   · 「合法取值集合」由清单派生（`DeviceRegistry.devices`）；
- *   · 「归一化外部输入」用清单派生的白名单（`asKnownDevice`）——不再要求宿主另传。
- *
- * @author yijiu2025
- * @since 2026-10-17（从 oauth21/src/theme/views/devices.ts 的转发函数收编）
- */
-import { containersOf } from './device.js';
-import type { DeviceDef, DeviceMatchContext } from './device.js';
-import { asDeviceId, deviceContext, deviceLabel, pickDeviceId } from './device.js';
-
-export type { DeviceDef, DeviceMatchContext } from './device.js';
-
-/**
- * 一套设备注册表 —— 宿主「设备这件事」的**全部**能力
- *
- * 所有函数都已绑定传入的清单，调用方不再需要每次传 `defs`。
- * `T` 是容器加载器的类型（纯逻辑侧透传、不关心它到底是什么）。
- */
-export interface DeviceRegistry<T = unknown> {
-  /** 设备 id 清单（顺序即优先级）—— 词汇表的**唯一来源** */
-  readonly defs: readonly DeviceDef<T>[];
-  /** 设备 id 数组（顺序即优先级） */
-  readonly devices: readonly string[];
-  /** 兜底设备 id */
-  readonly defaultDevice: string;
-  /** 设备 id → 中文名（调试面板 / 日志用；未知 id 原样返回） */
-  deviceLabel(id: string): string;
-  /** 归一化外部传入的设备名；不认识的取值返回 null（**不是**落默认设备） */
-  asKnownDevice(raw: unknown): string | null;
-  /** 从外部输入判定「本次访问属于哪台设备」；返回值永远非空（落 defaultDevice） */
-  pickDeviceId(ctx: DeviceMatchContext): string;
-  /** 取某设备的容器表（`containers` 是泛型 T，原样透传） */
-  containersOf(id: string): ReadonlyMap<string, T>;
-  /** 从当前访问信息构造判定上下文 */
-  deviceContext(
-    query: Record<string, unknown> | undefined,
-    path: string,
-    viewportIsMobile: boolean
-  ): DeviceMatchContext;
-}
-
-export interface DeviceRegistryOptions {
-  /** 兜底设备 id（判定全 miss 时返回）；缺省取清单最后一条的 id */
-  defaultDevice?: string;
-}
-
-/**
- * 从一份设备清单装配出整套设备机制
- *
- * @param defs 设备清单（顺序即优先级，末条建议无条件命中作兜底）
- * @param options 兜底设备等可选项
- *
- * @example
- * ```ts
- * const registry = createDeviceRegistry(THEME_DEVICE_DEFS, { defaultDevice: 'mobile' });
- * registry.pickDeviceId(registry.deviceContext(query, path, isMobile));
- * registry.asKnownDevice('mini'); // → 'mini' | null
- * ```
- */
-export function createDeviceRegistry<T>(
-  defs: readonly DeviceDef<T>[],
-  options: DeviceRegistryOptions = {}
-): DeviceRegistry<T> {
-  const defaultDevice = options.defaultDevice ?? defs[defs.length - 1]?.id ?? '';
-  const devices = defs.map(def => def.id);
-
-  return {
-    defs,
-    devices,
-    defaultDevice,
-    deviceLabel: (id: string) => deviceLabel(defs, id),
-    asKnownDevice: (raw: unknown) => asDeviceId(devices, raw),
-    pickDeviceId: (ctx: DeviceMatchContext) => pickDeviceId(defs, ctx, defaultDevice),
-    containersOf: (id: string) => containersOf(defs, id),
-    deviceContext
-  };
-}

package/src/vue/viewport.ts

@@ -1,54 +0,0 @@
-/**
- * 视口 / UA 设备形态判定（**纯浏览器判定**，SSR 安全）
- *
- * 从 `oauth21/src/utils/device.ts` 下沉（2026-10-19）。判定口径只有这一份：
- * 设备域（`device-domain`）用它的响应式版判「当前设备」，宿主守卫 / 请求拦截等
- * 用它的纯函数版判「跳哪个登录页」—— 两边同源，不再漂移。
- *
- * === 判定口径（三级，宽视口优先于 UA）===
- *   1. 视口 ≥ 1024px（DESKTOP_MIN_WIDTH）→ 电脑版（UA 说什么都不例外）
- *   2. 视口 < 768px（MOBILE_BREAKPOINT）→ 移动端
- *   3. 中间段（768–1023）→ UA 命中真机才算移动端（该区间可能是被缩放的桌面浏览器）
- *
- * === 为什么宽视口优先于 UA（2026-09-21 线上问题）===
- * 平板横屏 / 折叠屏展开 / 手机开「桌面版网站」时 UA 仍报手机、视口却有 1024px+，
- * 恒定按 UA 判移动端会把移动端版式铺满整屏。宽度比 UA 更贴近「这块屏放不放得下
- * 桌面布局」这个真问题。
- *
- * @author yijiu2025
- * @since 2026-10-19（从 oauth21/src/utils/device.ts 下沉，供设备域与宿主共用）
- */
-
-/** 移动端判定阈值（px）：窄于它说明视口放不下桌面双栏布局 */
-export const MOBILE_BREAKPOINT = 768;
-
-/** 桌面端判定阈值（px）：宽于等于它说明屏幕放得下完整桌面布局（对齐 Tailwind lg 断点） */
-export const DESKTOP_MIN_WIDTH = 1024;
-
-/**
- * UA 兜底检测：视口宽度会被窗口缩放 / 分屏 / DevTools 模拟影响，
- * UA 能识别「真手机/平板」（新版 iPad UA 已不含 iPad，走 maxTouchPoints 兜底）。
- */
-export function detectMobileUA(): boolean {
-  if (typeof navigator === 'undefined') return false;
-  const ua = navigator.userAgent || '';
-  const uaMobile = /Android|iPhone|iPod|Windows Phone|IEMobile|BlackBerry|Opera Mini/i.test(ua);
-  const iPadLike =
-    /iPad/i.test(ua) ||
-    (/Macintosh/i.test(ua) && typeof navigator.maxTouchPoints === 'number' && navigator.maxTouchPoints > 1);
-  return uaMobile || iPadLike;
-}
-
-/** 视口是否已宽到该用电脑版（只看宽度，不看 UA） */
-export function isDesktopViewport(): boolean {
-  if (typeof window === 'undefined') return false;
-  return window.innerWidth >= DESKTOP_MIN_WIDTH;
-}
-
-/** 当前是否应按移动端处理（一次性判定；SSR / 无 window 环境返回 false = 桌面默认） */
-export function isMobileViewport(): boolean {
-  if (typeof window === 'undefined') return false;
-  if (isDesktopViewport()) return false;
-  if (detectMobileUA()) return true;
-  return window.innerWidth < MOBILE_BREAKPOINT;
-}