@zhin.js/plugin-lottery 1.0.1 → 1.0.2

package/plugin.ts

@@ -0,0 +1,106 @@
+import {
+  definePlugin,
+  databaseHostToken,
+  outboundHostToken,
+  scheduleHostToken,
+} from '@zhin.js/plugin-runtime';
+import {
+  lotteryEnabledGames,
+  lotteryKl8,
+  resolveLotteryConfig,
+  type LotteryConfig,
+} from './src/config.js';
+import { defineLotteryTables } from './src/db.js';
+import { registerLotteryDb } from './src/db-store.js';
+import { registerLotteryAgentDeps } from './src/lottery-agent-deps.js';
+import { createInMemoryLotteryDb } from './src/memory-db.js';
+import { lotteryRuntimeToken } from './src/runtime-state.js';
+import { runLotteryPipeline } from './src/pipeline.js';
+import { registerLotteryOutboundPush } from './src/push.js';
+
+/**
+ * Plugin Runtime:
+ * - DB: prefer databaseHostToken; else memory.
+ * - Push: OutboundHost + config.pushTargets (cron / publish).
+ * - Cron: scheduleHostToken daily pipeline.
+ */
+export default definePlugin<LotteryConfig>({
+  name: 'lottery',
+  metadata: {
+    displayName: 'Lottery',
+  },
+  setup(context) {
+    const config = resolveLotteryConfig(context.config.get());
+    const db = context.resources.has(databaseHostToken)
+      ? context.resources.use(databaseHostToken)
+      : createInMemoryLotteryDb();
+    if (context.resources.has(databaseHostToken)) {
+      defineLotteryTables(db);
+    }
+    context.resources.provide(lotteryRuntimeToken, { db });
+    context.lifecycle.add(registerLotteryDb(db));
+
+    let outboundPush: ((text: string) => Promise<void>) | null = null;
+    if (context.resources.has(outboundHostToken) && config.pushTargets.length > 0) {
+      const outbound = context.resources.use(outboundHostToken);
+      outboundPush = async (text) => {
+        for (const target of config.pushTargets) {
+          try {
+            await outbound.send({
+              adapter: target.adapter,
+              endpointId: target.endpointId || target.adapter,
+              channelType: target.channelType || 'private',
+              channelId: target.channelId,
+              content: text,
+            });
+          } catch {
+            // OutboundHost logs; continue remaining targets.
+          }
+        }
+      };
+    }
+    context.lifecycle.add(registerLotteryOutboundPush(outboundPush));
+
+    context.lifecycle.add(registerLotteryAgentDeps({
+      getDb: () => db,
+      getConfig: () => ({
+        pickCount: config.pickCount,
+        historyLimit: config.historyLimit,
+        kl8: lotteryKl8(config),
+      }),
+      enabledGames: () => lotteryEnabledGames(config),
+      scheduleCron: () => config.scheduleCron,
+      scheduleEnabled: () => config.scheduleEnabled,
+      pipelinePush: config.pushTargets.length > 0,
+    }));
+
+    if (!context.resources.has(scheduleHostToken) || !config.scheduleEnabled) {
+      return;
+    }
+    const schedule = context.resources.use(scheduleHostToken);
+    const dispose = schedule.register({
+      id: 'lottery/daily_pipeline',
+      cron: config.scheduleCron || '0 0 18 * * *',
+      description: 'Daily lottery pipeline',
+      async execute() {
+        await runLotteryPipeline({
+          getDb: () => db,
+          enabledGames: () => lotteryEnabledGames(config),
+          historyLimit: config.historyLimit,
+          pickCount: config.pickCount,
+          kl8: lotteryKl8(config),
+          backtest: {
+            enabled: config.backtestEnabled,
+            window: config.backtestWindow,
+            randomTrials: config.backtestRandomTrials,
+            minHistory: config.backtestMinHistory,
+            adaptive: config.backtestAdaptive,
+          },
+          weightPersist: config.weightPersistEnabled,
+          weightHoldoutFallback: config.weightHoldoutFallback,
+        }, { push: config.pushTargets.length > 0 });
+      },
+    });
+    context.lifecycle.add(dispose);
+  },
+});

package/schema.json

@@ -0,0 +1,52 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "pickCount": { "type": "number", "default": 5, "minimum": 1, "maximum": 10 },
+    "scheduleCron": { "type": "string", "default": "0 0 18 * * *" },
+    "historyLimit": { "type": "number", "default": 500, "minimum": 50, "maximum": 2000 },
+    "scheduleEnabled": { "type": "boolean", "default": true },
+    "backtestEnabled": { "type": "boolean", "default": true },
+    "backtestWindow": { "type": "number", "default": 50 },
+    "backtestRandomTrials": { "type": "number", "default": 64 },
+    "backtestMinHistory": { "type": "number", "default": 30 },
+    "backtestAdaptive": { "type": "boolean", "default": true },
+    "weightPersistEnabled": { "type": "boolean", "default": true },
+    "weightHoldoutFallback": { "type": "boolean", "default": true },
+    "games": {
+      "type": "array",
+      "items": { "type": "string" },
+      "default": ["kl8", "ssq", "dlt", "fc3d", "pl3", "pl5"]
+    },
+    "pushTargets": {
+      "type": "array",
+      "description": "OutboundHost push destinations for cron/publish reports",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["adapter", "channelId"],
+        "properties": {
+          "adapter": { "type": "string" },
+          "endpointId": { "type": "string" },
+          "channelType": { "type": "string", "default": "private" },
+          "channelId": { "type": "string" }
+        }
+      },
+      "default": []
+    },
+    "kl8": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "pickCount": { "type": "number", "default": 5 },
+        "recommendGroups": { "type": "number", "default": 3 },
+        "groupStrategies": {
+          "type": "array",
+          "items": { "type": "string" },
+          "default": ["balanced", "hot", "cold"]
+        }
+      }
+    }
+  }
+}

package/src/command-helpers.ts

@@ -0,0 +1,35 @@
+import {
+  lotteryEnabledGames,
+  lotteryKl8,
+  resolveLotteryConfig,
+  type LotteryConfig,
+} from './config.js';
+import { getLotteryDb } from './db-store.js';
+import type { LotteryDb } from './db.js';
+import { formatPipelineReply, runLotteryPipeline, type PipelineDeps } from './pipeline.js';
+
+export function buildPipelineDeps(
+  raw: Partial<LotteryConfig> | undefined,
+  db: LotteryDb | null = getLotteryDb(),
+): PipelineDeps {
+  const config = resolveLotteryConfig(raw);
+  return {
+    getDb: () => db,
+    enabledGames: () => lotteryEnabledGames(config),
+    historyLimit: config.historyLimit,
+    pickCount: config.pickCount,
+    kl8: lotteryKl8(config),
+    backtest: {
+      enabled: config.backtestEnabled,
+      window: config.backtestWindow,
+      randomTrials: config.backtestRandomTrials,
+      minHistory: config.backtestMinHistory,
+      adaptive: config.backtestAdaptive,
+    },
+    weightPersist: config.weightPersistEnabled,
+    weightHoldoutFallback: config.weightHoldoutFallback,
+  };
+}
+
+export { formatPipelineReply, runLotteryPipeline, resolveLotteryConfig, getLotteryDb };
+export type { LotteryConfig };

package/src/config.ts

@@ -0,0 +1,83 @@
+import type { Kl8Config, Kl8ConfigInput } from './games/kl8-groups.js';
+import { resolveKl8Config } from './games/kl8-groups.js';
+import type { GameId } from './types.js';
+import { resolveEnabledGames } from './games/registry.js';
+
+export interface LotteryConfig {
+  readonly pickCount: number;
+  readonly scheduleCron: string;
+  readonly historyLimit: number;
+  readonly scheduleEnabled: boolean;
+  readonly backtestEnabled: boolean;
+  readonly backtestWindow: number;
+  readonly backtestRandomTrials: number;
+  readonly backtestMinHistory: number;
+  readonly backtestAdaptive: boolean;
+  readonly weightPersistEnabled: boolean;
+  readonly weightHoldoutFallback: boolean;
+  readonly kl8?: Kl8ConfigInput;
+  readonly games: readonly string[];
+  /** Plugin Runtime OutboundHost push targets (cron / publish). */
+  readonly pushTargets: readonly LotteryPushTargetConfig[];
+}
+
+export interface LotteryPushTargetConfig {
+  readonly adapter: string;
+  readonly endpointId?: string;
+  readonly channelType?: string;
+  readonly channelId: string;
+}
+
+export const DEFAULT_LOTTERY_CONFIG: LotteryConfig = {
+  pickCount: 5,
+  scheduleCron: '0 0 18 * * *',
+  historyLimit: 500,
+  scheduleEnabled: true,
+  backtestEnabled: true,
+  backtestWindow: 50,
+  backtestRandomTrials: 64,
+  backtestMinHistory: 30,
+  backtestAdaptive: true,
+  weightPersistEnabled: true,
+  weightHoldoutFallback: true,
+  kl8: {
+    pickCount: 5,
+    recommendGroups: 3,
+    groupStrategies: ['balanced', 'hot', 'cold'],
+  },
+  games: ['kl8', 'ssq', 'dlt', 'fc3d', 'pl3', 'pl5'],
+  pushTargets: [],
+};
+
+export function resolveLotteryConfig(raw: Partial<LotteryConfig> | undefined): LotteryConfig {
+  const pushTargets = Array.isArray(raw?.pushTargets)
+    ? raw!.pushTargets
+        .filter((t): t is LotteryPushTargetConfig =>
+          !!t && typeof t === 'object'
+          && typeof t.adapter === 'string'
+          && typeof t.channelId === 'string'
+          && t.adapter.length > 0
+          && t.channelId.length > 0)
+        .map((t) => Object.freeze({
+          adapter: t.adapter,
+          endpointId: typeof t.endpointId === 'string' ? t.endpointId : t.adapter,
+          channelType: typeof t.channelType === 'string' ? t.channelType : 'private',
+          channelId: t.channelId,
+        }))
+    : [];
+  return {
+    ...DEFAULT_LOTTERY_CONFIG,
+    ...raw,
+    games: raw?.games?.length ? [...raw.games] : [...DEFAULT_LOTTERY_CONFIG.games],
+    kl8: { ...DEFAULT_LOTTERY_CONFIG.kl8, ...raw?.kl8 },
+    pushTargets,
+  };
+}
+
+export function lotteryKl8(config: LotteryConfig): Kl8Config {
+  return resolveKl8Config(config.pickCount, config.kl8);
+}
+
+export function lotteryEnabledGames(config: LotteryConfig): GameId[] {
+  return resolveEnabledGames([...config.games]);
+}

package/src/db-store.ts

@@ -0,0 +1,34 @@
+import type { LotteryDb } from './db.js';
+import { createInMemoryLotteryDb } from './memory-db.js';
+
+let _db: LotteryDb | null = null;
+const registrations: Array<{ readonly value: LotteryDb }> = [];
+
+/** Ensure an in-memory store when Runtime database Resource is not wired yet. */
+export function ensureLotteryMemoryDb(): LotteryDb {
+  if (!_db) _db = createInMemoryLotteryDb();
+  return _db;
+}
+
+export function getLotteryDb(): LotteryDb | null {
+  return registrations[registrations.length - 1]?.value ?? ensureLotteryMemoryDb();
+}
+
+export function setLotteryDb(db: LotteryDb | null): void {
+  _db = db;
+}
+
+/** Generation-owned database binding used by Plugin Runtime setup(). */
+export function registerLotteryDb(db: LotteryDb): () => void {
+  const registration = Object.freeze({ value: db });
+  registrations.push(registration);
+  return () => {
+    const index = registrations.lastIndexOf(registration);
+    if (index >= 0) registrations.splice(index, 1);
+  };
+}
+
+/** Test helper: clear module store. */
+export function resetLotteryDb(): void {
+  _db = null;
+}

package/src/index.ts

@@ -1,216 +1,13 @@
-/**
- * @zhin.js/plugin-lottery — scheduled pipeline: sync → review → recommend → push
- */
-import { formatCompact, MessageCommand, Schema, usePlugin } from 'zhin.js';
-import type { GameId } from './types.js';
-import { parseGameId, resolveEnabledGames } from './games/registry.js';
-import {
-  defineLotteryTables,
-  loadDraws,
-  type LotteryDb,
-} from './db.js';
-import {
-  formatDailyReportText,
-  loadTodayReport,
-} from './recommend/report.js';
-import { recommendGame, formatPickLine, formatPickStats } from './recommend/game-pick.js';
-import {
-  loadAccuracySnapshot,
-  loadGameWeights,
-} from './evaluate/tracker.js';
-import { setLotteryAgentDeps } from './lottery-agent-deps.js';
-import { formatPipelineReply, runLotteryPipeline } from './pipeline.js';
-import { formatBacktestSection, formatTrainReport, runBacktestForGames, trainAllGameWeights } from './evaluate/backtest.js';
-import { resolveKl8Config, type Kl8ConfigInput } from './games/kl8-groups.js';
-
-const plugin = usePlugin();
-const { logger, addCommand, useContext, onDispose, declareConfig } = plugin;
-
-const config = declareConfig(
-  'lottery',
-  Schema.object({
-    pickCount: Schema.number().default(5).min(1).max(10).description('KL8 pick count'),
-    scheduleCron: Schema.string().default('0 0 18 * * *').description('Daily pipeline cron (sync→review→recommend→push)'),
-    historyLimit: Schema.number().default(500).min(50).max(2000).description('Max draws kept per game'),
-    scheduleEnabled: Schema.boolean().default(true).description('Enable scheduled pipeline'),
-    agentEnabled: Schema.boolean().default(true).description('AI narrative on daily report (optional)'),
-    backtestEnabled: Schema.boolean().default(true).description('Walk-forward backtest vs random baseline in report'),
-    backtestWindow: Schema.number().default(50).min(10).max(300).description('Backtest periods per game'),
-    backtestRandomTrials: Schema.number().default(64).min(10).max(500).description('Monte Carlo random trials per period'),
-    backtestMinHistory: Schema.number().default(30).min(10).max(150).description('Min history before walk-forward'),
-    backtestAdaptive: Schema.boolean().default(true).description('Per-period weight tuning in backtest simulation'),
-    weightPersistEnabled: Schema.boolean().default(true).description('Persist simulated F/O/T weights to lottery_model_weights'),
-    weightHoldoutFallback: Schema.boolean().default(true).description('Use DEFAULT weights when holdout adaptive loses to random'),
-    kl8: Schema.object({
-      pickCount: Schema.number().default(5).min(1).max(10).description('Numbers per KL8 group (选N)'),
-      recommendGroups: Schema.number().default(3).min(1).max(10).description('KL8 recommendation rows per day'),
-      groupStrategies: Schema.list(Schema.string()).default(['balanced', 'hot', 'cold']),
-    }).description('KL8 multi-strategy groups'),
-    games: Schema.list(Schema.string()).default(['kl8', 'ssq', 'dlt', 'fc3d', 'pl3', 'pl5']),
-  }),
-);
-
-let _db: LotteryDb | null = null;
-
-function getDb(): LotteryDb | null {
-  return _db;
-}
-
-function enabledGames(): GameId[] {
-  return resolveEnabledGames(config.games as string[]);
-}
-
-function pipelineDeps() {
-  const kl8 = resolveKl8Config(config.pickCount, config.kl8 as Kl8ConfigInput | undefined);
-  return {
-    getDb,
-    plugin,
-    enabledGames,
-    historyLimit: config.historyLimit,
-    pickCount: config.pickCount,
-    kl8,
-    agentEnabled: config.agentEnabled,
-    backtest: {
-      enabled: config.backtestEnabled,
-      window: config.backtestWindow,
-      randomTrials: config.backtestRandomTrials,
-      minHistory: config.backtestMinHistory,
-      adaptive: config.backtestAdaptive,
-    },
-    weightPersist: config.weightPersistEnabled,
-    weightHoldoutFallback: config.weightHoldoutFallback,
-  };
-}
-
-function refreshLotteryAgentDeps(): void {
-  setLotteryAgentDeps({
-    getDb: () => _db,
-    getConfig: () => ({
-      pickCount: config.pickCount,
-      historyLimit: config.historyLimit,
-      kl8: resolveKl8Config(config.pickCount, config.kl8 as Kl8ConfigInput | undefined),
-    }),
-    plugin,
-    enabledGames,
-    scheduleCron: () => config.scheduleCron,
-    scheduleEnabled: () => config.scheduleEnabled,
-    pipelinePush: true,
-  });
-}
-
-refreshLotteryAgentDeps();
-
-useContext('database', (db: unknown) => {
-  const d = db as { define: (n: string, s: Record<string, unknown>) => void };
-  defineLotteryTables(d);
-  _db = db as LotteryDb;
-  refreshLotteryAgentDeps();
-  logger.debug(formatCompact({ op: 'lottery-ready', schedule: config.scheduleEnabled }));
-});
-
-onDispose(() => {});
-
-// ─── Commands ───────────────────────────────────────────────────────────────
-
-addCommand(
-  new MessageCommand('lottery [game:word]')
-    .desc('Run full pipeline: sync → review → recommend (manual, no push)')
-    .action(async (_msg, result) => {
-      const gid = parseGameId(result.params.game ?? '');
-      const out = await runLotteryPipeline(pipelineDeps(), { gameId: gid ?? undefined, push: false });
-      return formatPipelineReply(out);
-    }),
-);
-
-addCommand(
-  new MessageCommand('lottery-train [game:word]')
-    .desc('Full-history weight training: predict→compare→tune from DEFAULT, persist to DB')
-    .action(async (_msg, result) => {
-      const db = getDb();
-      if (!db) return '数据库未就绪';
-      const gid = parseGameId(result.params.game ?? '');
-      const gameIds = gid ? [gid] : enabledGames();
-      const results = await trainAllGameWeights(db, gameIds, {
-        pickCount: config.pickCount,
-        minHistory: config.backtestMinHistory,
-        historyLimit: config.historyLimit,
-        randomTrials: config.backtestRandomTrials,
-        holdoutWindow: config.backtestWindow,
-        holdoutFallback: config.weightHoldoutFallback,
-        persist: true,
-      });
-      return formatTrainReport(results);
-    }),
-);
-
-addCommand(
-  new MessageCommand('lottery-backtest [game:word]')
-    .desc('Walk-forward backtest: strategy vs random baseline (no betting)')
-    .action(async (_msg, result) => {
-      const db = getDb();
-      if (!db) return '数据库未就绪';
-      const gid = parseGameId(result.params.game ?? '');
-      const gameIds = gid ? [gid] : enabledGames();
-      const summaries = await runBacktestForGames(db, gameIds, {
-        pickCount: config.pickCount,
-        window: config.backtestWindow,
-        randomTrials: config.backtestRandomTrials,
-        minHistory: config.backtestMinHistory,
-        historyLimit: config.historyLimit,
-        adaptive: config.backtestAdaptive,
-      });
-      const text = formatBacktestSection(summaries);
-      return text || '历史数据不足，请先执行 lottery 同步开奖';
-    }),
-);
-
-addCommand(
-  new MessageCommand('lottery-today')
-    .desc('Show today published recommendation report')
-    .action(async () => {
-      const db = getDb();
-      if (!db) return '数据库未就绪';
-      const report = await loadTodayReport(db);
-      if (!report) return '今日尚无推荐，可执行 lottery 或等待定时任务';
-      return formatDailyReportText(report, '');
-    }),
-);
-
-addCommand(
-  new MessageCommand('lottery-stats <game:word>')
-    .desc('Single-game stats snapshot (code engine)')
-    .action(async (_msg, result) => {
-      const gid = parseGameId(result.params.game ?? '');
-      if (!gid) return '请指定玩法';
-      const db = getDb();
-      if (!db) return '数据库未就绪';
-      const draws = await loadDraws(db, gid, config.historyLimit);
-      if (!draws.length) return '暂无数据，请先 lottery';
-      const kl8 = resolveKl8Config(config.pickCount, config.kl8 as Kl8ConfigInput | undefined);
-      const pick = recommendGame(gid, draws, {
-        pickCount: gid === 'kl8' ? kl8.pickCount : config.pickCount,
-        tieSeed: 'stats',
-        weights: await loadGameWeights(db, gid),
-        accuracy: await loadAccuracySnapshot(db, gid),
-        kl8: gid === 'kl8' ? kl8 : undefined,
-      });
-      return [formatPickLine(pick), formatPickStats(pick), `样本 ${draws.length} 期`].join('\n');
-    }),
-);
-
-addCommand(
-  new MessageCommand('lottery-history <game:word> [count:number=10]')
-    .desc('List historical draw results')
-    .action(async (_msg, result) => {
-      const gid = parseGameId(result.params.game ?? '');
-      if (!gid) return '请指定玩法';
-      const db = getDb();
-      if (!db) return '数据库未就绪';
-      const count = Math.min(50, Math.max(1, Number(result.params.count) || 10));
-      const draws = await loadDraws(db, gid, count);
-      if (!draws.length) return '暂无数据';
-      return draws.map((d) => `${d.issue} ${d.drawTime} ${JSON.stringify(d.numbers)}`).join('\n');
-    }),
-);
-
-export default plugin;
+export { resolveLotteryConfig, DEFAULT_LOTTERY_CONFIG } from './config.js';
+export type { LotteryConfig } from './config.js';
+export {
+  getLotteryDb,
+  registerLotteryDb,
+  setLotteryDb,
+  ensureLotteryMemoryDb,
+  resetLotteryDb,
+} from './db-store.js';
+export { createInMemoryLotteryDb } from './memory-db.js';
+export { lotteryRuntimeToken, resolveLotteryRuntime } from './runtime-state.js';
+export type { LotteryRuntime } from './runtime-state.js';
+export { formatPipelineReply, runLotteryPipeline } from './pipeline.js';

package/src/lottery-agent-deps.ts

@@ -2,7 +2,6 @@
  * Shared runtime deps for lottery agent/ authoring tools.
  * Set once from plugin index during init — never call getPlugin() from tool execute.
  */
-import type { Plugin } from 'zhin.js';
 import type { GameId } from './types.js';
 import type { LotteryDb } from './db.js';
 import type { Kl8Config } from './games/kl8-groups.js';
@@ -10,7 +9,6 @@ import type { Kl8Config } from './games/kl8-groups.js';
 export interface LotteryAgentDeps {
   getDb: () => LotteryDb | null;
   getConfig: () => { pickCount: number; historyLimit: number; kl8: Kl8Config };
-  plugin: Plugin;
   enabledGames: () => GameId[];
   scheduleCron: () => string;
   scheduleEnabled: () => boolean;
@@ -18,12 +16,24 @@ export interface LotteryAgentDeps {
 }
 
 let _deps: LotteryAgentDeps | null = null;
+const registrations: Array<{ readonly value: LotteryAgentDeps }> = [];
 
 export function setLotteryAgentDeps(deps: LotteryAgentDeps): void {
   _deps = deps;
 }
 
+/** Generation-owned Agent dependency binding used by Plugin Runtime setup(). */
+export function registerLotteryAgentDeps(deps: LotteryAgentDeps): () => void {
+  const registration = Object.freeze({ value: deps });
+  registrations.push(registration);
+  return () => {
+    const index = registrations.lastIndexOf(registration);
+    if (index >= 0) registrations.splice(index, 1);
+  };
+}
+
 export function getLotteryAgentDeps(): LotteryAgentDeps {
-  if (!_deps) throw new Error('lottery agent deps not initialized');
-  return _deps;
+  const deps = registrations[registrations.length - 1]?.value ?? _deps;
+  if (!deps) throw new Error('lottery agent deps not initialized');
+  return deps;
 }

package/src/lottery-tool-handlers.ts

@@ -14,7 +14,7 @@ import {
   loadAgentMemory,
 } from './evaluate/tracker.js';
 import { saveDailyReport } from './recommend/report.js';
-import { pushTextToMasters } from './push.js';
+import { pushLotteryReport, getLotteryOutboundPush } from './push.js';
 import { normalizeWeights } from './stats/weights.js';
 import { getLotteryAgentDeps } from './lottery-agent-deps.js';
 
@@ -142,8 +142,8 @@ export async function handlePublishReport(content: string, push?: boolean): Prom
   if (!text.includes(DISCLAIMER)) return 'content must include disclaimer';
   const date = new Date().toISOString().slice(0, 10);
   await saveDailyReport(db, { date, picks: [] as never[], disclaimer: DISCLAIMER, body: text }, text);
-  const doPush = push === true;
-  if (doPush) await pushTextToMasters(deps.plugin, text);
+  const doPush = push === true && Boolean(getLotteryOutboundPush());
+  if (doPush) await pushLotteryReport(text);
   return JSON.stringify({ ok: true, date, pushed: doPush });
 }
 

package/src/memory-db.ts

@@ -0,0 +1,60 @@
+import type { LotteryDb, LotteryModel } from './db.js';
+import {
+  DRAWS_TABLE,
+  REPORTS_TABLE,
+} from './db.js';
+import {
+  MEMORY_TABLE,
+  PREDICTIONS_TABLE,
+  WEIGHTS_TABLE,
+} from './evaluate/tracker.js';
+
+/** Minimal in-memory model matching LotteryModel (select/insert/delete). */
+function createMemoryModel(): LotteryModel {
+  const rows: Record<string, unknown>[] = [];
+
+  function matches(row: Record<string, unknown>, query: Record<string, unknown>): boolean {
+    return Object.entries(query).every(([key, value]) => row[key] === value);
+  }
+
+  return {
+    select: () => ({
+      where: async (query: Record<string, unknown>) => rows.filter((row) => matches(row, query)),
+    }),
+    insert: async (row: Record<string, unknown>) => {
+      rows.push({ ...row });
+      return row;
+    },
+    delete: () => ({
+      where: async (query: Record<string, unknown>) => {
+        for (let i = rows.length - 1; i >= 0; i -= 1) {
+          if (matches(rows[i]!, query)) rows.splice(i, 1);
+        }
+      },
+    }),
+  };
+}
+
+const TABLE_NAMES = [
+  DRAWS_TABLE,
+  REPORTS_TABLE,
+  PREDICTIONS_TABLE,
+  WEIGHTS_TABLE,
+  MEMORY_TABLE,
+] as const;
+
+/**
+ * Slice-2 fallback while Plugin Runtime has no DatabaseFeature Resource path.
+ * Enough for smoke: today/history/stats/train/backtest/pipeline no longer return「数据库未就绪」.
+ */
+export function createInMemoryLotteryDb(): LotteryDb {
+  const models = new Map<string, LotteryModel>();
+  for (const name of TABLE_NAMES) {
+    models.set(name, createMemoryModel());
+  }
+  return {
+    models: {
+      get: (name: string) => models.get(name),
+    },
+  };
+}