dsh-router-core 0.1.0 → 0.2.0

package/src/router/models-cache.test.ts

@@ -0,0 +1,186 @@
+/**
+ * 模型缓存（核心统一）测试 —— 组合面板不该每次都打上游。
+ * 用 node --test 跑（Node 原生 TS 剥离，零新依赖）。
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { Router } from './index.ts'
+import type { ServerResponse } from 'node:http'
+import type { ModelInfo, ModelWithEnabled } from './types.ts'
+import type { AccountPool } from './account-pool.ts'
+import type { ChatOnceResult, SupplierAccountNow, SupplierStatusNow } from '../suppliers/contract.ts'
+import { AccountPool as Pool } from './account-pool.ts'
+
+/**
+ * 记 listModels 调用次数的假供应商。
+ * 默认带一个账号（走真实账号循环），模型不属于自己时报 no_such_model
+ * （与真实插件一致）。
+ */
+function supplier(id: string, models: ModelInfo[], delayMs = 0) {
+  const state = { calls: 0 }
+  const accts: SupplierAccountNow[] = [{ uid: 'u1', credits: 0, state: 'ok' }]
+  return {
+    state,
+    s: {
+      id,
+      name: id,
+      priority: 0,
+      status: (): SupplierStatusNow => ({ id, name: id, accounts: accts }),
+      listModels: async (): Promise<ModelInfo[]> => {
+        state.calls += 1
+        if (delayMs > 0) await new Promise((r) => setTimeout(r, delayMs))
+        return models
+      },
+      modelsWithEnabled: async (): Promise<ModelWithEnabled[]> =>
+        models.map((m) => ({ ...m, enabled: true })),
+      getAlias: (): string => id,
+      accounts: (): SupplierAccountNow[] => accts,
+      chatOnce: async (uid: string, req: { rawBody: string }): Promise<ChatOnceResult> => {
+        const m = (JSON.parse(req.rawBody) as { model?: string }).model ?? ''
+        if (!models.some((mm) => mm.id === m)) {
+          return { ok: false, state: 'no_such_model', message: `unknown model ${m}` }
+        }
+        void uid
+        return { ok: true, status: 200, body: '{"ok":1}' }
+      },
+      dispose: (): void => {},
+      pool: new Pool() as AccountPool,
+    },
+  }
+}
+
+/** 丢弃响应的假 ServerResponse。 */
+function fakeRes(): ServerResponse {
+  return {
+    writeHead: (): unknown => undefined,
+    end: (): unknown => undefined,
+    write: (): boolean => true,
+    once: (): unknown => undefined,
+    removeListener: (): unknown => undefined,
+    destroy: (): unknown => undefined,
+  } as unknown as ServerResponse
+}
+
+function addSupplier(router: Router, s: unknown): void {
+  // supplierModels/modelsOf 走 this.suppliers，测试里直接塞进去
+  ;(router as unknown as { suppliers: unknown[] }).suppliers.push(s)
+}
+
+test('组合面板连开两次只拉一次上游（缓存生效）', async () => {
+  const router = new Router('')
+  const a = supplier('a', [{ id: 'a-1' }])
+  const b = supplier('b', [{ id: 'b-1' }])
+  addSupplier(router, a.s)
+  addSupplier(router, b.s)
+
+  await router.supplierModels()
+  await router.supplierModels()
+  await router.supplierModels()
+
+  assert.equal(a.state.calls, 1)
+  assert.equal(b.state.calls, 1)
+})
+
+test('detail 与 combos 共用同一份缓存', async () => {
+  const router = new Router('')
+  const a = supplier('a', [{ id: 'a-1' }])
+  addSupplier(router, a.s)
+
+  const viaDetail = await router.modelsOf('a')
+  const viaCombos = await router.supplierModels()
+
+  assert.equal(a.state.calls, 1)
+  assert.equal(viaDetail.length, 1)
+  assert.equal(viaCombos[0]?.models.length, 1)
+})
+
+test('各供应商并行拉取：总耗时取最慢的那个，不是累加', async () => {
+  const router = new Router('')
+  // 三个各慢 200ms：串行会是 600ms+，并行约 200ms
+  for (const id of ['s1', 's2', 's3']) addSupplier(router, supplier(id, [{ id: `${id}-m` }], 200).s)
+
+  const t0 = Date.now()
+  await router.supplierModels()
+  const dt = Date.now() - t0
+
+  assert.ok(dt < 500, `并行拉取应在 500ms 内，实测 ${dt}ms`)
+})
+
+test('失效缓存后重新拉取；force 强制刷新', async () => {
+  const router = new Router('')
+  const a = supplier('a', [{ id: 'a-1' }])
+  addSupplier(router, a.s)
+
+  await router.modelsOf('a')
+  assert.equal(a.state.calls, 1)
+
+  router.invalidateModels('a')
+  await router.modelsOf('a')
+  assert.equal(a.state.calls, 2)
+
+  await router.modelsOf('a', true)
+  assert.equal(a.state.calls, 3)
+})
+
+test('单个供应商拉模型失败不影响其它供应商', async () => {
+  const router = new Router('')
+  const bad = supplier('bad', [])
+  bad.s.listModels = async (): Promise<ModelInfo[]> => {
+    throw new Error('upstream down')
+  }
+  const good = supplier('good', [{ id: 'g-1' }])
+  addSupplier(router, bad.s)
+  addSupplier(router, good.s)
+
+  const groups = await router.supplierModels()
+  assert.equal(groups.length, 1)
+  assert.equal(groups[0]?.supplier.id, 'good')
+})
+
+test('未知供应商返回空，不抛错', async () => {
+  const router = new Router('')
+  assert.deepEqual(await router.modelsOf('nonexistent'), [])
+})
+
+/**
+ * 对照组：插件若用 unavailable 表示「不是我的模型」就会污染账号——
+ * 这正是当初把 no_such_model 加进契约的原因（unavailable 在 RULES 里计数）。
+ * 这条锁住「为什么必须区分这两个状态」，别退化回去。
+ */
+test('对照：用 unavailable 表示「不是我的模型」会污染账号', async () => {
+  const router = new Router('')
+  const other = supplier('other', [{ id: 'other-m' }])
+  // 模拟旧行为：不是我的模型也报 unavailable（会计数）
+  other.s.chatOnce = async (): Promise<ChatOnceResult> =>
+    ({ ok: false, state: 'unavailable', message: 'not my model' })
+  addSupplier(router, other.s)
+
+  const req = { model: 'want-m', stream: false, rawBody: JSON.stringify({ model: 'want-m', messages: [] }) }
+  for (let i = 0; i < 5; i++) await router.chatCompletions(req, fakeRes())
+
+  const acc = other.s.pool.decorate([{ uid: 'u1', credits: 0, state: 'ok' }])[0]
+  assert.equal(acc?.cooling, true, 'unavailable 会计数，攒够阈值就该冷却——这正说明必须区分状态')
+})
+
+/**
+ * 回归：组合里指定别人家的模型，不能把无关供应商的账号攒错误冷却掉。
+ * 历史上插件用 unavailable 表示「不是我的模型」，核心计成连续错误，
+ * 攒够 3 次就把无辜账号冷却 10 分钟——组合越用越「没号可用」。
+ */
+test('组合请求不污染无关供应商的账号（no_such_model 不记账）', async () => {
+  const router = new Router('')
+  const other = supplier('other', [{ id: 'other-m' }])
+  const target = supplier('target', [{ id: 'want-m' }])
+  addSupplier(router, other.s)
+  addSupplier(router, target.s)
+
+  const req = { model: 'want-m', stream: false, rawBody: JSON.stringify({ model: 'want-m', messages: [] }) }
+  const res = fakeRes()
+  // 连打 5 次（远超错误阈值 3）
+  for (let i = 0; i < 5; i++) await router.chatCompletions(req, res)
+
+  const acc = other.s.pool.decorate([{ uid: 'u1', credits: 0, state: 'ok' }])[0]
+  assert.equal(acc?.err_count, 0, '不该累计连续错误')
+  assert.equal(acc?.cooling, false, '不该被冷却')
+  assert.equal(acc?.disabled, false, '不该被禁用')
+})

package/src/router/types.ts

@@ -3,7 +3,8 @@
  * 每个供应商提供 OpenAI 兼容的 chat/models，并暴露面板状态。
  * 仿 9router：供应商 = 一种"免费/付费"通道；dsh-router 在其上做路由。
  */
-import type { ServerResponse } from 'node:http'
+import type { ChatOnceResult, SupplierAccountNow } from '../suppliers/contract.ts'
+import type { AccountPool } from './account-pool.ts'
 
 /** 面板展示的账号状态（脱敏）。 */
 export interface SupplierAccount {
@@ -57,9 +58,8 @@ export interface ChatRequest {
 }
 
 /**
- * 供应商接口。chatCompletions 直接向 res 写响应（流式 SSE 或 JSON），
- * 成功返回 true；返回 false 表示"该供应商无健康账号可服务"（触发路由器
- * 轮换到下一个供应商）。写响应后不得再改 res。
+ * 供应商接口。核心负责账号池（选号/冷却/禁用/错误累计/遍历回退），
+ * 供应商只对**单个账号**调一次上游并报告结果，不碰 res。
  */
 export interface Supplier {
   readonly id: string
@@ -76,10 +76,15 @@ export interface Supplier {
   getAlias(): string
   /** 用户手动添加的模型 id（可选，/v1/models 用它聚合自定义模型）。 */
   customModelIds?(): string[]
-  chatCompletions(req: ChatRequest, res: ServerResponse): Promise<boolean>
-  /** 测试模型（验证上游真实可用，必要差异化能力）。 */
-  testModel(id: string): Promise<{ ok: boolean; error?: string }>
+  /** 账号「现在状态」（从 status() 派生，插件只报它观察到的）。空 = 无账号供应商。 */
+  accounts(): SupplierAccountNow[]
+  /** 对单个账号调一次上游。不遍历账号、不管冷却、不写 res。 */
+  chatOnce(uid: string, req: ChatRequest): Promise<ChatOnceResult>
+  /** 上次 chatOnce 失败原因（诊断用，可选）。 */
+  lastError?(): string | undefined
   /** 删除链接（清理凭证；内部能力，js 契约不要求实现）。 */
   removeLink?(uid: string): Promise<boolean>
   dispose(): void
+  /** 该供应商的账号池（核心持有：选号/冷却/禁用/错误累计）。 */
+  readonly pool: AccountPool
 }

package/src/supplier-config.ts

@@ -5,7 +5,6 @@
  *   - 别名 alias(前缀,模型全名 = alias/id)
  *   - 模型管理:启用/禁用 disabled、自定义 custom
  *   - 连接池:poolOrder(拖动排序)、poolStrategy(回退/轮询)
- *   - 签到规则 checkinRule(所有链接 / 首个链接)
  *
  * 持久化到 data/supplier-config.json。
  */
@@ -13,7 +12,6 @@ import { mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 
 export type PoolStrategy = 'fallback' | 'round-robin'
-export type CheckinRule = 'all' | 'first'
 
 export interface SupplierConfig {
   alias: string
@@ -21,7 +19,6 @@ export interface SupplierConfig {
   custom: string[]
   poolOrder: string[]
   poolStrategy: PoolStrategy
-  checkinRule: CheckinRule
 }
 
 interface ConfigFile {
@@ -42,7 +39,7 @@ export class SupplierConfigStore {
   get(supplierId: string): SupplierConfig {
     let cfg = this.bySupplier.get(supplierId)
     if (!cfg) {
-      cfg = { alias: '', disabled: [], custom: [], poolOrder: [], poolStrategy: 'fallback', checkinRule: 'all' }
+      cfg = { alias: '', disabled: [], custom: [], poolOrder: [], poolStrategy: 'fallback' }
       this.bySupplier.set(supplierId, cfg)
     }
     return cfg
@@ -91,12 +88,6 @@ export class SupplierConfigStore {
     this.saveLocked()
   }
 
-  setCheckinRule(supplierId: string, rule: string): void {
-    if (rule !== 'all' && rule !== 'first') return
-    this.get(supplierId).checkinRule = rule
-    this.saveLocked()
-  }
-
   private load(): void {
     if (this.fp === '') return
     let f: ConfigFile
@@ -112,7 +103,6 @@ export class SupplierConfigStore {
         custom: Array.isArray(c.custom) ? c.custom.filter((m) => typeof m === 'string') : [],
         poolOrder: Array.isArray(c.poolOrder) ? c.poolOrder.filter((u) => typeof u === 'string') : [],
         poolStrategy: c.poolStrategy === 'round-robin' ? 'round-robin' : 'fallback',
-        checkinRule: c.checkinRule === 'first' ? 'first' : 'all',
       })
     }
   }
@@ -127,7 +117,6 @@ export class SupplierConfigStore {
         custom: [...cfg.custom],
         poolOrder: [...cfg.poolOrder],
         poolStrategy: cfg.poolStrategy,
-        checkinRule: cfg.checkinRule,
       }
     }
     try {

package/src/suppliers/contract.ts

@@ -9,8 +9,7 @@
  * 用户自定义供应商 js 放到 `~/.dsh/profiles/web/suppliers/*.js`，重启后自动加载。
  * 内置供应商与用户 js 同构（差异化能力驱动）。
  */
-import type { ServerResponse } from 'node:http'
-import type { ChatRequest, ModelInfo, SupplierAccount, SupplierStatus } from '../router/types.ts'
+import type { ChatRequest, ModelInfo, SupplierAccount } from '../router/types.ts'
 import type { SupplierConfigStore } from '../supplier-config.ts'
 import type { CredentialStore } from '../credential-store.ts'
 
@@ -29,6 +28,58 @@ export interface SupplierEnv {
 /** 通用供应商工厂：一个 js 模块 export 它（或 default export 它），loader 调用得到实例。 */
 export type SupplierFactory = (env: SupplierEnv) => SupplierModule
 
+/**
+ * 账户此刻的状态 —— 插件**解读**上游信号后的语义状态。
+ *
+ * 插件只报「现在怎么了」，不说「该怎么办」：冷却多久、是否禁用、要不要换号
+ * 都是核心的策略，见 `AccountState` 各值的处置表（docs/suppliers.md）。
+ *
+ * 天花板：目前是固定枚举。若将来某供应商需要更细的语义，再加值而不是放宽成
+ * 字符串——核心的策略表要能穷举。
+ */
+export type AccountState =
+  | 'ok'            // 正常
+  | 'rate_limit'    // 限流（429 类）
+  | 'quota'         // 额度/权益不足
+  | 'session_dead'  // 凭证彻底失效，必须重新登录才能恢复
+  | 'unavailable'   // 上游不可用（404 / 服务下线）
+  | 'transport'     // 网络/连接层失败（没拿到 HTTP 状态）
+  | 'unknown'       // 说不清是什么错
+  /**
+   * 这个模型不属于本供应商（不是账号的失败，也不是上游故障）。
+   * 核心据此**跳过整个供应商**换下一个，而不是记在账号头上——
+   * 否则组合里每有一个别人家的模型，就会给无关账号攒一次错误，攒够阈值
+   * 把它冷却掉（历史上正是这个坑）。
+   */
+  | 'no_such_model'
+
+/** 面板展示的账号此刻状态（插件只报它观察到的部分，冷却/禁用由核心叠加）。 */
+export interface SupplierAccountNow {
+  uid: string
+  nickname?: string
+  credits: number
+  /** 插件观察到的上游状态。 */
+  state: AccountState
+  /** 状态的人类可读补充（如上游错误串），可选。 */
+  message?: string
+}
+
+/** 插件报的供应商状态（accounts 是「现在状态」，非核心加工后的面板态）。 */
+export interface SupplierStatusNow {
+  id: string
+  name: string
+  accounts: SupplierAccountNow[]
+}
+
+/** 一次上游调用的结果。 */
+export type ChatOnceResult =
+  /** 流式：插件已把上游协议转成 OpenAI SSE，核心只负责 pipe 到 res。 */
+  | { ok: true; stream: ReadableStream<Uint8Array> }
+  /** 非流式：核心写 JSON。 */
+  | { ok: true; status: number; body: string }
+  /** 失败：核心据此做冷却/禁用/换号。 */
+  | { ok: false; state: AccountState; message: string }
+
 /** 供应商模块 —— 契约（核心必须，差异化可选）。 */
 export interface SupplierModule {
   /** 供应商唯一 id（小写字母数字 - _）。 */
@@ -41,18 +92,29 @@ export interface SupplierModule {
   readonly icon?: string
 
   // ---- 核心（必须） ----
-  status(): SupplierStatus
+  /** 报账号「现在状态」。冷却/禁用/错误累计由核心叠加，插件不算这些。 */
+  status(): SupplierStatusNow
   /** 模型来源。`force=true` 时强制刷新来源（核心「获取模型」按钮调用）。 */
   listModels(force?: boolean): Promise<ModelInfo[]> | ModelInfo[]
   /** 默认前缀（可被通用层 alias 覆盖）。 */
   getAlias(): string
-  chatCompletions(req: ChatRequest, res: ServerResponse): Promise<boolean>
-  /** 测试模型（验证上游真实可用，必要差异化能力）。 */
-  testModel(id: string): Promise<{ ok: boolean; error?: string }>
+  /**
+   * 对**单个账号**调一次上游。插件不遍历账号、不管冷却、不写 res——
+   * 选号/回退/健康判定全是核心的活。
+   * 无账号供应商（如 opencode）传空 uid，忽略即可。
+   */
+  chatOnce(uid: string, req: ChatRequest): Promise<ChatOnceResult>
   dispose(): void
 
   // ---- 差异化能力（可选，按存在性暴露端点/UI） ----
 
+  /** 上次 chatOnce 失败的原因（诊断用）。
+   *  测试模型由 dsh-router 核心统一走 chatOnce 路径（账号池回退/冷却自动生效），
+   *  插件只需把失败原因暴露出来供核心汇总；不实现则测试失败时只有通用提示。 */
+  lastError?(): string | undefined
+
+  // ---- 差异化能力（可选，按存在性暴露端点/UI） ----
+
   /** 生成登录链接（加账号）。有它才显示连接池（账号池）。 */
   generateLoginUrl?(): string | { ok: boolean; error?: string; loginUrl?: string } | Promise<string | { ok: boolean; error?: string; loginUrl?: string }>
   /** 回调完成登录。 */
@@ -65,8 +127,9 @@ export interface SupplierModule {
   /** 轮询式登录标记：有它 → 面板隐藏「粘贴回调链接」步骤，登录后直接点完成（后台轮询）。 */
   pollLogin?(): boolean
 
-  /** 触发签到。签到规则(all/first)是 dsh-router 通用策略,不在此列。 */
-  checkinNow?(): Promise<{ ok: boolean; total: number; succeeded: number; already?: number; error?: string; results?: Array<{ uid: string; ok: boolean; status?: string; message?: string }> }>
+  /** 单个链接签到。遍历所有链接 + 结果汇总是 dsh-router 核心的活,插件只管一个 uid。
+   *  status: 'ok'(签到成功) / 'already'(今日已签到) / 'error'(失败)。 */
+  checkinNow?(uid: string): Promise<{ ok: boolean; status: string; message?: string }>
 }
 
 /** 供应商账号（复用 router 类型，供 loader 包装）。 */

package/src/suppliers/loader.ts

@@ -13,7 +13,8 @@ import type { ServerResponse } from 'node:http'
 import type { ChatRequest, ModelInfo, ModelWithEnabled, Supplier, SupplierStatus } from '../router/types.ts'
 import type { SupplierConfigStore } from '../supplier-config.ts'
 import type { CredentialStore } from '../credential-store.ts'
-import type { SupplierEnv, SupplierFactory, SupplierModule } from './contract.ts'
+import type { ChatOnceResult, SupplierAccountNow, SupplierEnv, SupplierFactory, SupplierModule } from './contract.ts'
+import { AccountPool } from '../router/account-pool.ts'
 
 /** 供应商加载错误（不阻断其他供应商）。 */
 export interface SupplierLoadError {
@@ -43,7 +44,6 @@ function resolveModule(mod: Record<string, unknown>, file: string): SupplierModu
   if (typeof cand !== 'object' || cand === null) throw new Error(`供应商模块无效: ${file}`)
   if (typeof cand.id !== 'string' || cand.id === '') throw new Error(`供应商缺少 id: ${file}`)
   if (typeof cand.name !== 'string' || cand.name === '') throw new Error(`供应商缺少 name: ${file}`)
-  if (typeof cand.testModel !== 'function') throw new Error(`供应商 ${cand.id} 缺少 testModel（必要差异化能力）: ${file}`)
   return cand as unknown as SupplierModule
 }
 
@@ -56,7 +56,7 @@ async function importSupplierFile(file: string): Promise<SupplierModule> {
 
 /**
  * 差异化能力（供应商 js 实现；其余为通用能力由核心提供）。
- * testModel 是必要差异化能力（核心必须），不在此列。
+ * testModel / 连接池 / 模型管理 / 别名 / 凭证存储均为核心通用能力，不在此列。
  */
 const DIFF_CAPS = [
   'generateLoginUrl', 'completeLogin',
@@ -75,9 +75,7 @@ async function loadOne(file: string, env: SupplierEnv, source: 'builtin' | 'user
     if (typeof instance !== 'object' || instance === null || typeof instance.id !== 'string' || instance.id === '') {
       throw new Error(`供应商 factory 返回无效: ${file}`)
     }
-    if (typeof instance.testModel !== 'function') {
-      throw new Error(`供应商 ${instance.id} 缺少 testModel（必要差异化能力）: ${file}`)
-    }
+    // 测试模型由核心统一走 chatOnce 路径，插件无需实现 testModel
   } else {
     instance = mod
   }
@@ -92,20 +90,25 @@ export function wrapModule(instance: SupplierModule, env: SupplierEnv, source: s
   if (typeof instance !== 'object' || instance === null || typeof instance.id !== 'string' || instance.id === '') {
     throw new Error(`供应商模块无效: ${source}`)
   }
-  if (typeof instance.testModel !== 'function') {
-    throw new Error(`供应商 ${instance.id} 缺少 testModel（必要差异化能力）: ${source}`)
-  }
+  // 测试模型由核心统一走 chatOnce 路径（账号池回退/冷却自动生效），插件无需实现 testModel
   const capabilities = new Set<string>()
   for (const key of DIFF_CAPS) {
     if (isFn((instance as unknown as Record<string, unknown>)[key])) capabilities.add(key)
   }
 
+  // 账号池由核心持有（选号/冷却/禁用/错误累计），插件不参与。
+  // 挂在 supplier 上：status() 叠加状态与 Router 的 chat 循环共用同一实例。
+  const pool = new AccountPool()
+
   const supplier: Supplier = {
     id: instance.id,
     name: instance.name,
     priority: instance.priority ?? 0,
     icon: (instance as { icon?: string }).icon,
-    status: (): SupplierStatus => instance.status(),
+    status: (): SupplierStatus => {
+      const now = instance.status()
+      return { id: now.id, name: now.name, accounts: pool.decorate(now.accounts) }
+    },
     listModels: (force?: boolean): Promise<ModelInfo[]> | ModelInfo[] => instance.listModels(force),
     // 通用能力：模型启用状态/自定义由核心 SupplierConfigStore 合并
     modelsWithEnabled: (force?: boolean): Promise<ModelWithEnabled[]> | ModelWithEnabled[] => {
@@ -122,13 +125,17 @@ export function wrapModule(instance: SupplierModule, env: SupplierEnv, source: s
     },
     getAlias: (): string => env.store.get(instance.id).alias || instance.getAlias(),
     customModelIds: (): string[] => [...env.store.get(instance.id).custom],
-    chatCompletions: (req: ChatRequest, res: ServerResponse): Promise<boolean> => instance.chatCompletions(req, res),
-    testModel: (id: string): Promise<{ ok: boolean; error?: string }> => instance.testModel(id),
+    accounts: (): SupplierAccountNow[] => instance.status().accounts,
+    chatOnce: (uid: string, req: ChatRequest): Promise<ChatOnceResult> => instance.chatOnce(uid, req),
+    lastError: isFn((instance as unknown as Record<string, unknown>).lastError)
+      ? (): string | undefined => (instance as unknown as { lastError(): string | undefined }).lastError()
+      : undefined,
     // 删除链接：数据删除是通用能力，凭证清理由供应商内部实现（js 契约不要求）
     removeLink: isFn((instance as unknown as Record<string, unknown>).removeLink)
       ? (uid: string): Promise<boolean> => (instance as unknown as { removeLink(uid: string): Promise<boolean> }).removeLink(uid)
       : undefined,
     dispose: (): void => instance.dispose(),
+    pool,
   }
   // 差异化路由通过 LoadedSupplier.capabilities + supplier 实例调用面板方法
   ;(supplier as Supplier & { __module?: SupplierModule }).__module = instance