@prajwalshete/telegram-plugin 0.0.0-stage → 0.1.0

package/dist/engine/schedules/fire.js

@@ -0,0 +1,208 @@
+import { decideMissed } from "../../core/schedule/policy.js";
+import { topics } from "../../core/recipients.js";
+import { nextRun, nextRuns } from "../../core/schedule/rule.js";
+import { sql } from "../../ports/sql.js";
+import { TelegramPluginError, isTelegramPluginError } from "../errors.js";
+import { templateById, templateModel } from "../content/template-rows.js";
+import { fanOut } from "../content/fanout.js";
+import { resolveRecipients } from "../content/recipients.js";
+import { missedPolicyOf, scheduleParams, scheduleRecipients, scheduleRule } from "./rows.js";
+// src/engine/schedules/fire.ts
+/** Claim lease (docs/06 §6.2). */
+const CLAIM_MS = 12e4;
+/** Base dedupe key of one chat (+ forum topic) for a slot; `:<part>` is appended per part. */
+function scheduleDedupeKey(scheduleId, slotAt, chat) {
+	const base = `sched:${scheduleId}:${slotAt}:${chat.chatRef}`;
+	return chat.messageThreadId ? `${base}#${chat.messageThreadId}` : base;
+}
+/** The latest slot ≤ `now`, starting from the planned `first` one (catch-up runs only the latest). */
+function latestSlot(rule, tz, first, now) {
+	let slot = first;
+	for (let i = 0; i < 100; i++) {
+		const more = nextRuns(rule, tz, slot, 500).filter((s) => s <= now);
+		const last = more.at(-1);
+		if (last === void 0) return slot;
+		slot = last;
+		if (more.length < 500) return slot;
+	}
+	return slot;
+}
+function codeOf(e) {
+	return isTelegramPluginError(e) ? e.code : "error";
+}
+async function runDeliveries(rt, runId) {
+	return (await rt.db.first(sql`SELECT COUNT(*) AS n FROM tg_delivery WHERE tenant = ${rt.tenant} AND source = 'schedule' AND source_id = ${runId}`))?.n ?? 0;
+}
+/** Fans one run out and records its outcome. Never throws: failures mark the run `failed`. */
+async function executeRun(rt, schedule, run, opts = {}) {
+	let status = "done";
+	let deliveries = 0;
+	let error = null;
+	let templateVersion = null;
+	const bots = /* @__PURE__ */ new Set();
+	try {
+		const row = await templateById(rt, schedule.template_id);
+		if (!row) throw new TelegramPluginError("not_found", "template not found");
+		const template = templateModel(row);
+		templateVersion = template.version;
+		const now = rt.clock.now();
+		const recipients = await resolveRecipients(rt, scheduleRecipients(schedule), {
+			topic: topics.schedule(schedule.id),
+			now
+		});
+		if (recipients.send.length + recipients.held.length === 0) {
+			if (recipients.muted.length === 0) error = "recipient_empty";
+		} else {
+			const out = await fanOut(rt, {
+				template,
+				params: scheduleParams(schedule),
+				recipients,
+				personalize: schedule.personalize === 1,
+				source: "schedule",
+				sourceId: run.id,
+				dedupeKey: (chat) => scheduleDedupeKey(schedule.id, run.slotAt, chat),
+				now,
+				tz: schedule.timezone,
+				meta: {
+					schedule: schedule.id,
+					run: run.id
+				},
+				fileTags: {
+					schedule: schedule.id,
+					run: run.id
+				}
+			});
+			deliveries = opts.resumed ? await runDeliveries(rt, run.id) : out.deliveries;
+			if (out.errors.length > 0) {
+				status = deliveries > 0 ? "partial" : "failed";
+				error = out.errors.join(",");
+			}
+			for (const r of [...recipients.send, ...recipients.held.map((h) => h.chat)]) bots.add(r.botId);
+		}
+	} catch (e) {
+		rt.log.warn("tg.schedule_run_failed", {
+			schedule: schedule.id,
+			code: codeOf(e)
+		});
+		status = "failed";
+		error = codeOf(e);
+	}
+	const finishedAt = rt.clock.now();
+	await rt.db.batch([sql`UPDATE tg_schedule_run SET status = ${status}, deliveries = ${deliveries}, error = ${error},
+          finished_at = ${finishedAt}, template_version = ${templateVersion}
+        WHERE tenant = ${rt.tenant} AND id = ${run.id}`, sql`UPDATE tg_schedule SET last_run_at = ${run.startedAt}, last_status = ${status}
+        WHERE tenant = ${rt.tenant} AND id = ${schedule.id}`]);
+	rt.log.info("tg.schedule_run", {
+		schedule: schedule.id,
+		trigger: run.trigger,
+		status,
+		deliveries
+	});
+	if (opts.selfBotId !== void 0) bots.delete(opts.selfBotId);
+	if (deliveries > 0 && bots.size > 0) try {
+		await rt.transport.kick([...bots]);
+	} catch (e) {
+		rt.log.warn("tg.kick_failed", { error: e instanceof Error ? e.name : "error" });
+	}
+	return {
+		id: run.id,
+		tenant: rt.tenant,
+		schedule_id: schedule.id,
+		slot_at: run.slotAt,
+		trigger: run.trigger,
+		started_at: run.startedAt,
+		finished_at: finishedAt,
+		status,
+		deliveries,
+		error,
+		template_version: templateVersion
+	};
+}
+/**
+* A claimed schedule: missed policy, then ONE batch guarded by the claim token that inserts the run row (unique
+* per slot) and advances `next_run_at` past `max(slot, now)`, releasing the claim. Fan-out only follows a newly
+* inserted run row. Returns the run, or null when the slot already ran or the claim was lost.
+*/
+async function fireClaimed(rt, schedule, token, now, opts = {}) {
+	const planned = schedule.next_run_at;
+	if (planned === null) return null;
+	let slot;
+	let next;
+	try {
+		const rule = scheduleRule(schedule);
+		slot = latestSlot(rule, schedule.timezone, planned, now);
+		next = nextRun(rule, schedule.timezone, Math.max(slot, now));
+	} catch (e) {
+		rt.log.warn("tg.schedule_rule_broken", {
+			schedule: schedule.id,
+			code: e instanceof Error ? e.name : "error"
+		});
+		await rt.db.run(sql`UPDATE tg_schedule SET next_run_at = NULL, claim_until = NULL, claim_token = NULL, last_status = 'failed'
+          WHERE tenant = ${rt.tenant} AND id = ${schedule.id} AND claim_token = ${token}`);
+		return null;
+	}
+	const decision = decideMissed({
+		nextRunAt: slot,
+		now,
+		policy: missedPolicyOf(schedule),
+		graceMin: schedule.missed_grace_min
+	});
+	const runId = rt.ids.uuid();
+	const status = decision === "skip" ? "skipped" : "running";
+	const [inserted] = await rt.db.batch([sql`INSERT INTO tg_schedule_run (id, tenant, schedule_id, slot_at, trigger, started_at, finished_at, status, deliveries)
+        SELECT ${runId}, ${rt.tenant}, ${schedule.id}, ${slot}, 'schedule', ${now},
+          ${decision === "skip" ? now : null}, ${status}, 0
+        WHERE EXISTS (SELECT 1 FROM tg_schedule WHERE id = ${schedule.id} AND claim_token = ${token})
+        ON CONFLICT (schedule_id, slot_at) DO NOTHING`, sql`UPDATE tg_schedule SET next_run_at = ${next}, claim_until = NULL, claim_token = NULL,
+          last_status = ${status === "skipped" ? "skipped" : sql`last_status`}
+        WHERE tenant = ${rt.tenant} AND id = ${schedule.id} AND claim_token = ${token}`]);
+	if (!inserted || inserted.changes === 0) return null;
+	if (decision === "skip") {
+		rt.log.info("tg.schedule_skipped", {
+			schedule: schedule.id,
+			lateMs: now - slot
+		});
+		return {
+			id: runId,
+			tenant: rt.tenant,
+			schedule_id: schedule.id,
+			slot_at: slot,
+			trigger: "schedule",
+			started_at: now,
+			finished_at: now,
+			status: "skipped",
+			deliveries: 0,
+			error: null,
+			template_version: null
+		};
+	}
+	return executeRun(rt, schedule, {
+		id: runId,
+		slotAt: slot,
+		trigger: "schedule",
+		startedAt: now
+	}, opts);
+}
+/**
+* `run-now`: a `manual` run with `slot_at = now` (moved forward by 1 ms on a collision), same fan-out path.
+* `next_run_at` is not touched.
+*/
+async function runManual(rt, schedule) {
+	const now = rt.clock.now();
+	for (let slot = now; slot < now + 5; slot++) {
+		const runId = rt.ids.uuid();
+		if ((await rt.db.run(sql`INSERT INTO tg_schedule_run (id, tenant, schedule_id, slot_at, trigger, started_at, status, deliveries)
+          SELECT ${runId}, ${rt.tenant}, ${schedule.id}, ${slot}, 'manual', ${now}, 'running', 0
+          WHERE EXISTS (SELECT 1 FROM tg_schedule WHERE tenant = ${rt.tenant} AND id = ${schedule.id}
+                          AND deleted_at IS NULL)
+          ON CONFLICT (schedule_id, slot_at) DO NOTHING`)).changes === 1) return executeRun(rt, schedule, {
+			id: runId,
+			slotAt: slot,
+			trigger: "manual",
+			startedAt: now
+		});
+		if (!await rt.db.first(sql`SELECT 1 AS ok FROM tg_schedule WHERE tenant = ${rt.tenant} AND id = ${schedule.id} AND deleted_at IS NULL`)) throw new TelegramPluginError("not_found", "schedule not found");
+	}
+	throw new TelegramPluginError("rate_limited", "too many manual runs at once", { extensions: { retryAfter: 1 } });
+}
+export { CLAIM_MS, executeRun, fireClaimed, latestSlot, runManual, scheduleDedupeKey };

package/dist/engine/schedules/resume.js

@@ -0,0 +1,75 @@
+import { sql } from "../../ports/sql.js";
+import { scheduleById } from "./rows.js";
+import { executeRun } from "./fire.js";
+// src/engine/schedules/resume.ts
+/** A `running` run older than this is treated as cut off; attempt n is not tried before `started_at + n ×` this. */
+const STUCK_RUN_MS = 6e5;
+/** A stuck run older than this is never resumed (its messages would be stale), only marked `failed`. */
+const RESUME_MAX_AGE_MS = 36e5;
+/** Stuck runs looked at per tick. */
+const SWEEP_LIMIT = 10;
+const MARK = "resumed:";
+function resumesOf(error) {
+	if (error === null || !error.startsWith(MARK)) return 0;
+	const n = Number(error.slice(8));
+	return Number.isInteger(n) && n >= 0 ? n : 0;
+}
+/** Marks a stuck run `failed` (guarded by its current `error`, so only one tick does it). */
+async function giveUp(rt, run, code, now) {
+	const [res] = await rt.db.batch([sql`UPDATE tg_schedule_run SET status = 'failed', error = ${code}, finished_at = ${now}
+        WHERE tenant = ${rt.tenant} AND id = ${run.id} AND status = 'running' AND error IS ${run.error}`, sql`UPDATE tg_schedule SET last_run_at = ${run.started_at}, last_status = 'failed'
+        WHERE tenant = ${rt.tenant} AND id = ${run.schedule_id}
+          AND (last_run_at IS NULL OR last_run_at <= ${run.started_at})`]);
+	if (res && res.changes > 0) rt.log.warn("tg.schedule_run_stuck", {
+		schedule: run.schedule_id,
+		run: run.id,
+		code,
+		resumes: resumesOf(run.error)
+	});
+}
+/**
+* Resumes (or gives up on) `running` schedule runs older than `STUCK_RUN_MS`. Each attempt is claimed by a
+* compare-and-set on `error`, so concurrent ticks never resume one run twice at once. Returns runs resumed.
+*/
+async function resumeStuckRuns(rt, now) {
+	if (!rt.features.schedules) return 0;
+	const stuck = await rt.db.all(sql`SELECT * FROM tg_schedule_run WHERE tenant = ${rt.tenant} AND status = 'running'
+          AND started_at < ${now - STUCK_RUN_MS}
+        ORDER BY started_at LIMIT ${SWEEP_LIMIT}`);
+	let resumed = 0;
+	for (const run of stuck) try {
+		const n = resumesOf(run.error);
+		const age = now - run.started_at;
+		if (age < (n + 1) * 6e5) continue;
+		if (n >= 3 || age > 36e5) {
+			await giveUp(rt, run, "run_stuck", now);
+			continue;
+		}
+		const schedule = await scheduleById(rt, run.schedule_id);
+		if (!schedule) {
+			await giveUp(rt, run, "not_found", now);
+			continue;
+		}
+		if ((await rt.db.run(sql`UPDATE tg_schedule_run SET error = ${`${MARK}${n + 1}`}
+            WHERE tenant = ${rt.tenant} AND id = ${run.id} AND status = 'running' AND error IS ${run.error}`)).changes === 0) continue;
+		rt.log.warn("tg.schedule_run_resumed", {
+			schedule: schedule.id,
+			run: run.id,
+			attempt: n + 1
+		});
+		await executeRun(rt, schedule, {
+			id: run.id,
+			slotAt: run.slot_at,
+			trigger: run.trigger === "manual" ? "manual" : "schedule",
+			startedAt: run.started_at
+		}, { resumed: true });
+		resumed++;
+	} catch (e) {
+		rt.log.error("tg.schedule_resume_failed", {
+			run: run.id,
+			error: e instanceof Error ? e.name : "error"
+		});
+	}
+	return resumed;
+}
+export { RESUME_MAX_AGE_MS, STUCK_RUN_MS, resumeStuckRuns };

package/dist/engine/schedules/rows.js

@@ -0,0 +1,69 @@
+import { JsonObject } from "../../contracts/common.js";
+import { Recipients } from "../../contracts/recipients.js";
+import { MissedPolicy, ScheduleRule, ScheduleRunStatus, ScheduleRunTrigger } from "../../contracts/schedules.js";
+import { sql } from "../../ports/sql.js";
+import { TelegramPluginError } from "../errors.js";
+import { parseJson } from "../rows.js";
+// src/engine/schedules/rows.ts
+/** A stored rule that no longer parses never runs. */
+const NEVER = {
+	kind: "once",
+	at: "1970-01-01T00:00"
+};
+function scheduleRule(r) {
+	return parseJson(r.rule_json, ScheduleRule, NEVER);
+}
+function scheduleParams(r) {
+	return parseJson(r.params_json, JsonObject.nullable(), null);
+}
+function scheduleRecipients(r) {
+	return parseJson(r.recipients_json, Recipients, []);
+}
+function missedPolicyOf(r) {
+	return MissedPolicy.safeParse(r.missed_policy).data ?? "run_once";
+}
+function scheduleDto(r) {
+	return {
+		id: r.id,
+		name: r.name,
+		rule: scheduleRule(r),
+		timezone: r.timezone,
+		templateId: r.template_id,
+		params: scheduleParams(r),
+		recipients: scheduleRecipients(r),
+		personalize: r.personalize === 1,
+		missedPolicy: missedPolicyOf(r),
+		missedGraceMin: r.missed_grace_min,
+		enabled: r.enabled === 1,
+		pausedUntil: r.paused_until,
+		nextRunAt: r.next_run_at,
+		lastRunAt: r.last_run_at,
+		lastStatus: ScheduleRunStatus.safeParse(r.last_status).data ?? null,
+		createdBy: r.created_by,
+		createdAt: r.created_at,
+		updatedAt: r.updated_at
+	};
+}
+function scheduleRunDto(r) {
+	return {
+		id: r.id,
+		scheduleId: r.schedule_id,
+		slotAt: r.slot_at,
+		trigger: ScheduleRunTrigger.safeParse(r.trigger).data ?? "schedule",
+		startedAt: r.started_at,
+		finishedAt: r.finished_at,
+		status: ScheduleRunStatus.safeParse(r.status).data ?? "failed",
+		deliveries: r.deliveries,
+		error: r.error,
+		templateVersion: r.template_version
+	};
+}
+async function scheduleById(rt, id) {
+	return rt.db.first(sql`SELECT * FROM tg_schedule WHERE tenant = ${rt.tenant} AND id = ${id} AND deleted_at IS NULL`);
+}
+async function requireSchedule(rt, id) {
+	const row = await scheduleById(rt, id);
+	if (!row) throw new TelegramPluginError("not_found", "schedule not found");
+	return row;
+}
+export { missedPolicyOf, requireSchedule, scheduleById, scheduleDto, scheduleParams, scheduleRecipients, scheduleRule, scheduleRunDto };

package/dist/engine/schedules/tick.js

@@ -0,0 +1,30 @@
+import { sql } from "../../ports/sql.js";
+import { CLAIM_MS, fireClaimed } from "./fire.js";
+// src/engine/schedules/tick.ts
+/** One UPDATE … RETURNING: due, enabled, not paused, not deleted, not leased by another tick. */
+async function claimDueSchedules(rt, now, token) {
+	return rt.db.all(sql`UPDATE tg_schedule SET claim_until = ${now + CLAIM_MS}, claim_token = ${token}
+        WHERE id IN (SELECT id FROM tg_schedule
+                     WHERE tenant = ${rt.tenant} AND enabled = 1 AND deleted_at IS NULL
+                       AND (paused_until IS NULL OR paused_until <= ${now})
+                       AND next_run_at IS NOT NULL AND next_run_at <= ${now}
+                       AND (claim_until IS NULL OR claim_until < ${now})
+                     ORDER BY next_run_at LIMIT ${rt.limits.scheduleClaim})
+        RETURNING *`);
+}
+/** Claims and fires due schedules. Returns how many were claimed. */
+async function fireDueSchedules(rt, now, opts = {}) {
+	if (!rt.features.schedules) return 0;
+	const token = rt.ids.uuid();
+	const claimed = await claimDueSchedules(rt, now, token);
+	for (const row of claimed) try {
+		await fireClaimed(rt, row, token, now, opts);
+	} catch (e) {
+		rt.log.error("tg.schedule_fire_failed", {
+			schedule: row.id,
+			error: e instanceof Error ? e.name : "error"
+		});
+	}
+	return claimed.length;
+}
+export { claimDueSchedules, fireDueSchedules };

package/dist/engine/schedules/wake.js

@@ -0,0 +1,50 @@
+import { sql } from "../../ports/sql.js";
+import { isDoTransport, scheduleBotWake } from "../outbox/do-transport.js";
+import { fireDueSchedules } from "./tick.js";
+// src/engine/schedules/wake.ts
+/** Floor for a re-armed wake, so a held claim never makes an object spin on its alarm. */
+const MIN_WAKE_GAP_MS = 1e3;
+/** The bot whose object fires the tenant's schedules (null = no usable bot; the tick handles them). */
+async function schedulerBotId(rt) {
+	return (await rt.db.first(sql`SELECT id FROM tg_bot WHERE tenant = ${rt.tenant} AND deleted_at IS NULL
+          AND status IN ('active', 'webhook_error') ORDER BY created_at, id LIMIT 1`))?.id ?? null;
+}
+/**
+* When the next schedule can be claimed: MIN over live schedules of max(next_run_at, end of a timed pause, end of
+* a held claim). Indefinitely paused schedules never wake.
+*/
+async function nextScheduleAt(rt) {
+	return (await rt.db.first(sql`SELECT MIN(MAX(next_run_at, COALESCE(paused_until, 0), COALESCE(claim_until, 0))) AS at FROM tg_schedule
+        WHERE tenant = ${rt.tenant} AND enabled = 1 AND deleted_at IS NULL AND next_run_at IS NOT NULL
+          AND (paused_until IS NULL OR paused_until < ${0xe677d21fdbff})`))?.at ?? null;
+}
+/**
+* Sets the scheduler bot's object wake to the tenant's next schedule. Call it whenever a `next_run_at` changes
+* (create, edit, pause, resume, delete, a fired run). The wake is replaced, not merged, so a schedule that was
+* deleted or paused past its old slot does not leave a stale earlier alarm; no schedule left clears the wake.
+* No-op unless the DO transport is active; never throws.
+*/
+async function armScheduleWake(rt) {
+	if (!rt.features.schedules || !isDoTransport(rt.transport)) return false;
+	try {
+		const [botId, at] = await Promise.all([schedulerBotId(rt), nextScheduleAt(rt)]);
+		if (botId === null) return false;
+		await rt.transport.setWake(botId, at);
+		return at !== null;
+	} catch (e) {
+		rt.log.warn("tg.schedule_wake_failed", { error: e instanceof Error ? e.name : "error" });
+		return false;
+	}
+}
+/** The DO wake stage: fire due schedules, then return the next wake (scheduler bot) or hand it over (others). */
+async function scheduleWakeStage(rt, botId, now) {
+	if (!rt.features.schedules) return null;
+	await fireDueSchedules(rt, now, { selfBotId: botId });
+	const [scheduler, at] = await Promise.all([schedulerBotId(rt), nextScheduleAt(rt)]);
+	if (at === null) return null;
+	const next = Math.max(at, rt.clock.now() + MIN_WAKE_GAP_MS);
+	if (scheduler === botId) return next;
+	if (scheduler !== null) await scheduleBotWake(rt, scheduler, next);
+	return null;
+}
+export { armScheduleWake, nextScheduleAt, scheduleWakeStage, schedulerBotId };

package/dist/engine/state.d.ts

@@ -0,0 +1,11 @@
+/** Result of `ensureState`: whether the plugin tables match this version. */
+export interface SchemaState {
+  /** True when the schema is current; jobs and the webhook skip work otherwise (`schema_outdated`). */
+  ok: boolean;
+  /** `SCHEMA_VERSION` this build needs. */
+  required: number;
+  /** Version recorded in `tg_state`, or null when never written. */
+  current: number | null;
+  /** Tables the probe could not read and missing unique indexes as `index:<name>` (only when not ok). */
+  missing: string[];
+}

package/dist/engine/state.js

@@ -0,0 +1,78 @@
+import { sql } from "../ports/sql.js";
+import { TABLE_COLUMNS, UNIQUE_INDEXES } from "../schema/columns.js";
+// src/engine/state.ts
+const STATE_KEYS = {
+	schemaVersion: "schema_version",
+	lastTickAt: "last_tick_at",
+	lastCleanupAt: "last_cleanup_at",
+	lastRekeyAt: "last_rekey_at",
+	keyringActiveKid: "keyring_active_kid",
+	pollOffset: (botId) => `poll_offset:${botId}`,
+	botHealth: (botId) => `bot_health:${botId}`
+};
+async function getState(rt, key) {
+	return (await rt.db.first(sql`SELECT value FROM tg_state WHERE tenant = ${rt.tenant} AND key = ${key}`))?.value ?? null;
+}
+function setStateSql(rt, key, value, now) {
+	return sql`INSERT INTO tg_state (tenant, key, value, updated_at) VALUES (${rt.tenant}, ${key}, ${value}, ${now})
+             ON CONFLICT (tenant, key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`;
+}
+async function setState(rt, key, value, now) {
+	await rt.db.run(setStateSql(rt, key, value, now));
+}
+async function probe(db) {
+	const missing = [];
+	for (const [table, cols] of Object.entries(TABLE_COLUMNS)) try {
+		if (![table, ...cols].every((n) => /^[a-z_][a-z0-9_]*$/.test(n))) throw new Error("bad name");
+		await db.all(sql`SELECT ${sql.raw(cols.join(", "))} FROM ${sql.raw(table)} LIMIT 0`);
+	} catch {
+		missing.push(table);
+	}
+	try {
+		const rows = await db.all(sql`SELECT name FROM sqlite_master WHERE type = 'index'`);
+		const have = new Set(rows.map((r) => r.name));
+		for (const ix of UNIQUE_INDEXES) if (!have.has(ix)) missing.push(`index:${ix}`);
+	} catch {
+		missing.push("sqlite_master");
+	}
+	return missing;
+}
+/**
+* Bootstrap and guard. When `tg_state.schema_version` is behind (or missing), probes every plugin table for the
+* columns this version needs; if they all exist, records `SCHEMA_VERSION`. Safe to call on every cold start.
+*/
+async function ensureState(rt) {
+	let current = null;
+	try {
+		const v = await getState(rt, STATE_KEYS.schemaVersion);
+		current = v === null ? null : Number(v);
+	} catch {
+		return {
+			ok: false,
+			required: 2,
+			current: null,
+			missing: ["tg_state"]
+		};
+	}
+	if (current !== null && current >= 2) return {
+		ok: true,
+		required: 2,
+		current,
+		missing: []
+	};
+	const missing = await probe(rt.db);
+	if (missing.length > 0) return {
+		ok: false,
+		required: 2,
+		current,
+		missing
+	};
+	await setState(rt, STATE_KEYS.schemaVersion, String(2), rt.clock.now());
+	return {
+		ok: true,
+		required: 2,
+		current: 2,
+		missing: []
+	};
+}
+export { STATE_KEYS, ensureState, getState, setState, setStateSql };