@camstack/system 1.2.424 → 1.2.425

package/dist/builtins/addon-pages-aggregator/addon-pages-aggregator.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CiUKtVkX.js");
+const require_dist = require("../../dist-DnALrQF-.js");
 const require_settle_sources = require("../../settle-sources-Bhsy57y-.js");
 let node_crypto = require("node:crypto");
 let node_path = require("node:path");

package/dist/builtins/addon-pages-aggregator/addon-pages-aggregator.addon.mjs

@@ -1,4 +1,4 @@
-import { G as addonPagesCapability, cr as errMsg, lr as BaseAddon, ti as EventCategory } from "../../dist-B-NmfvVC.mjs";
+import { G as addonPagesCapability, cr as errMsg, lr as BaseAddon, ti as EventCategory } from "../../dist-DMWeqeTF.mjs";
 import { t as settleSourcesWithTimeout } from "../../settle-sources-CDtNC8ub.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import * as path$1 from "node:path";

package/dist/builtins/addon-widgets-aggregator/addon-widgets-aggregator.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CiUKtVkX.js");
+const require_dist = require("../../dist-DnALrQF-.js");
 const require_settle_sources = require("../../settle-sources-Bhsy57y-.js");
 let node_crypto = require("node:crypto");
 let node_path = require("node:path");

package/dist/builtins/addon-widgets-aggregator/addon-widgets-aggregator.addon.mjs

@@ -1,4 +1,4 @@
-import { cr as errMsg, lr as BaseAddon, q as addonWidgetsCapability, ti as EventCategory } from "../../dist-B-NmfvVC.mjs";
+import { cr as errMsg, lr as BaseAddon, q as addonWidgetsCapability, ti as EventCategory } from "../../dist-DMWeqeTF.mjs";
 import { t as settleSourcesWithTimeout } from "../../settle-sources-CDtNC8ub.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import * as path$1 from "node:path";

package/dist/builtins/alerts/alerts.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CiUKtVkX.js");
+const require_dist = require("../../dist-DnALrQF-.js");
 //#region src/builtins/alerts/device-label.ts
 /**
 * Operator-facing device label for alert messages.

package/dist/builtins/alerts/alerts.addon.mjs

@@ -1,4 +1,4 @@
-import { J as alertsCapability, Tr as createEvent, cr as errMsg, lr as BaseAddon, n as AlertSchema, ti as EventCategory } from "../../dist-B-NmfvVC.mjs";
+import { J as alertsCapability, Tr as createEvent, cr as errMsg, lr as BaseAddon, n as AlertSchema, ti as EventCategory } from "../../dist-DMWeqeTF.mjs";
 //#region src/builtins/alerts/device-label.ts
 /**
 * Operator-facing device label for alert messages.

package/dist/builtins/autotrack/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CiUKtVkX.js");
+const require_dist = require("../../dist-DnALrQF-.js");
 //#region src/builtins/autotrack/autotrack-config.ts
 var DEFAULT_AUTOTRACK_LOOP_CONFIG = {
 	deadZoneFraction: .5,

package/dist/builtins/autotrack/index.mjs

@@ -1,4 +1,4 @@
-import { C as FIRST_LEVEL_MACRO_CLASSES, Pr as isEvent, Z as bareAddonId, cr as errMsg, hn as ptzAutotrackCapability, lr as BaseAddon, ti as EventCategory } from "../../dist-B-NmfvVC.mjs";
+import { C as FIRST_LEVEL_MACRO_CLASSES, Pr as isEvent, Z as bareAddonId, cr as errMsg, hn as ptzAutotrackCapability, lr as BaseAddon, ti as EventCategory } from "../../dist-DMWeqeTF.mjs";
 //#region src/builtins/autotrack/autotrack-config.ts
 var DEFAULT_AUTOTRACK_LOOP_CONFIG = {
 	deadZoneFraction: .5,

package/dist/builtins/backup-orchestrator/backup-databases.d.ts

@@ -0,0 +1,51 @@
+/**
+* Which database files a backup carries, and when (D852).
+*
+* Settings is the one a decision reads and runs nightly. Events and history are
+* statistical or ledger stores; losing up to a week costs chart gaps, never
+* configuration, so they ride a WEEKLY schedule whose archive is a consistent
+* full set. Pure functions, no I/O: the orchestrator feeds them what it read.
+*/
+import type { DataStoreDatabase } from "@camstack/types";
+import type { BackupSchedule } from "./schedule-store.js";
+import type { SeedMarkers } from "./seed-marker-store.js";
+/** Stable id of the seeded weekly schedule. */
+export declare const WEEKLY_SCHEDULE_ID = "weekly-events-history";
+export declare const WEEKLY_SCHEDULE_LABEL = "Weekly — events & history";
+/** Sundays 04:00 — an hour after the nightly settings run. */
+export declare const WEEKLY_SCHEDULE_CRON = "0 4 * * 0";
+export declare const WEEKLY_SCHEDULE_RETENTION = 4;
+/**
+* Events and history ONLY: a run that does not select settings carries no
+* data-root walk either, so the weekly archive is just the two snapshots.
+*/
+export declare const WEEKLY_SCHEDULE_DATABASES: readonly DataStoreDatabase[];
+/** What a schedule carries: its own list, else the minimum (D382). */
+export declare function databasesOfSchedule(schedule: Pick<BackupSchedule, "databases">): readonly DataStoreDatabase[];
+/**
+* True when a run asks for a database beyond settings and the owner has none
+* of them open: the run would only repeat the nightly archive. A settings-only
+* run is never nothing-to-carry.
+*/
+export declare function hasNothingBeyondSettings(requested: readonly DataStoreDatabase[], owned: readonly DataStoreDatabase[]): boolean;
+/**
+* The weekly schedule to seed, or null. Created only when NO schedule carries
+* `events` (a seed never overwrites, D728 — an operator's own weekly schedule,
+* or an edited seed, is left alone), and only when there is a nightly schedule
+* to take the destinations from: a hub that backs up nowhere gets no weekly
+* archive either.
+*/
+export declare function planWeeklySeed(existing: readonly BackupSchedule[]): BackupSchedule | null;
+/** The slice of the schedule store the seed needs. */
+export interface ScheduleSeedStore {
+	list(): Promise<readonly BackupSchedule[]>;
+	upsert(schedule: BackupSchedule): Promise<void>;
+}
+/**
+* Seed the weekly schedule if {@link planWeeklySeed} says so; returns what it
+* wrote. Exactly once ever: the marker is written after the row, and a marker
+* that exists ends the seed for good — an operator who disabled or deleted the
+* weekly is never second-guessed. A weekly row found with no marker (seeded
+* before the marker existed) is marked, not re-created.
+*/
+export declare function seedWeeklySchedule(store: ScheduleSeedStore, markers: SeedMarkers): Promise<BackupSchedule | null>;

package/dist/builtins/backup-orchestrator/backup-orchestrator.addon.d.ts

@@ -249,6 +249,19 @@ export declare class BackupOrchestratorAddon extends BaseAddon<Record<string, ne
 	*/
 	private onScheduleTick;
 	/**
+	* A schedule that asks for events/history while the owner has neither open
+	* would only repeat the nightly archive (D852: the weekly schedule has
+	* nothing to carry until those files exist). Said on the record, no archive
+	* built, no outcome stamped. An owner that cannot answer never skips: the
+	* run goes ahead and fails — or succeeds — in the open.
+	*/
+	private nothingToCarry;
+	/**
+	* Seed the weekly "events & history" schedule (D852) — once, and never over
+	* anything the operator has: see `planWeeklySeed`.
+	*/
+	private seedWeekly;
+	/**
 	* Fire one schedule and RECORD what happened to it, naming every
 	* destination. Three outcomes, three different persisted states —
 	* because "fired" and "backed up" were the same field until D384:

package/dist/builtins/backup-orchestrator/backup-orchestrator.addon.js

@@ -3,8 +3,8 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CiUKtVkX.js");
-const require_restore_archive = require("../../restore-archive-DA-aJtg7.js");
+const require_dist = require("../../dist-DnALrQF-.js");
+const require_restore_archive = require("../../restore-archive-C4UhQOsg.js");
 let node_crypto = require("node:crypto");
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = require_chunk.__toESM(node_fs_promises);
@@ -12,6 +12,138 @@ let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);
+//#region src/builtins/backup-orchestrator/backup-databases.ts
+/** Stable id of the seeded weekly schedule. */
+var WEEKLY_SCHEDULE_ID = "weekly-events-history";
+var WEEKLY_SCHEDULE_LABEL = "Weekly — events & history";
+/** Sundays 04:00 — an hour after the nightly settings run. */
+var WEEKLY_SCHEDULE_CRON = "0 4 * * 0";
+/**
+* Events and history ONLY: a run that does not select settings carries no
+* data-root walk either, so the weekly archive is just the two snapshots.
+*/
+var WEEKLY_SCHEDULE_DATABASES = ["events", "history"];
+/** What a schedule carries: its own list, else the minimum (D382). */
+function databasesOfSchedule(schedule) {
+	return schedule.databases !== void 0 && schedule.databases.length > 0 ? schedule.databases : require_restore_archive.DEFAULT_BACKUP_DATABASES;
+}
+/**
+* True when a run asks for a database beyond settings and the owner has none
+* of them open: the run would only repeat the nightly archive. A settings-only
+* run is never nothing-to-carry.
+*/
+function hasNothingBeyondSettings(requested, owned) {
+	const extra = requested.filter((id) => id !== "settings");
+	if (extra.length === 0) return false;
+	return !extra.some((id) => owned.includes(id));
+}
+/**
+* The weekly schedule to seed, or null. Created only when NO schedule carries
+* `events` (a seed never overwrites, D728 — an operator's own weekly schedule,
+* or an edited seed, is left alone), and only when there is a nightly schedule
+* to take the destinations from: a hub that backs up nowhere gets no weekly
+* archive either.
+*/
+function planWeeklySeed(existing) {
+	if (existing.some((s) => s.id === "weekly-events-history")) return null;
+	if (existing.some((s) => databasesOfSchedule(s).includes("events"))) return null;
+	const destinations = /* @__PURE__ */ new Set();
+	for (const s of existing) {
+		if (!s.enabled) continue;
+		for (const id of s.locationIds) destinations.add(id);
+	}
+	if (destinations.size === 0) return null;
+	return {
+		id: WEEKLY_SCHEDULE_ID,
+		label: WEEKLY_SCHEDULE_LABEL,
+		cron: WEEKLY_SCHEDULE_CRON,
+		enabled: true,
+		locationIds: [...destinations].toSorted(),
+		retentionCount: 4,
+		databases: WEEKLY_SCHEDULE_DATABASES
+	};
+}
+/**
+* Seed the weekly schedule if {@link planWeeklySeed} says so; returns what it
+* wrote. Exactly once ever: the marker is written after the row, and a marker
+* that exists ends the seed for good — an operator who disabled or deleted the
+* weekly is never second-guessed. A weekly row found with no marker (seeded
+* before the marker existed) is marked, not re-created.
+*/
+async function seedWeeklySchedule(store, markers) {
+	if (await markers.has("weekly-events-history")) return null;
+	const existing = await store.list();
+	if (existing.some((s) => s.id === "weekly-events-history")) {
+		await markers.mark(WEEKLY_SCHEDULE_ID);
+		return null;
+	}
+	const seed = planWeeklySeed(existing);
+	if (seed === null) return null;
+	await store.upsert(seed);
+	await markers.mark(WEEKLY_SCHEDULE_ID);
+	return seed;
+}
+//#endregion
+//#region src/builtins/backup-orchestrator/seed-marker-store.ts
+/**
+* @durable class=config owner=backup-orchestrator
+*   write="the orchestrator inserts one row per seed id the first time that
+*     seed is created (or found already created); never updated"
+*   retention="none — one tiny row per seed ever made; deleting it lets the
+*     seed be re-created once more on the next boot"
+*/
+var BACKUP_SEED_MARKERS_COLLECTION = "backup_seed_markers";
+var COLUMNS$1 = [{
+	name: "seed_id",
+	type: "TEXT",
+	primaryKey: true
+}, {
+	name: "seeded_at",
+	type: "INTEGER",
+	notNull: true
+}];
+var BackupSeedMarkerStore = class {
+	store;
+	now;
+	declared = false;
+	constructor(store, now = Date.now) {
+		this.store = store;
+		this.now = now;
+	}
+	async ensureDeclared() {
+		if (this.declared) return;
+		await this.store.declareCollection({
+			collection: BACKUP_SEED_MARKERS_COLLECTION,
+			columns: COLUMNS$1
+		});
+		this.declared = true;
+	}
+	async has(seedId) {
+		await this.ensureDeclared();
+		return (await this.store.query({
+			collection: BACKUP_SEED_MARKERS_COLLECTION,
+			filter: {
+				where: { seed_id: seedId },
+				limit: 1
+			}
+		})).length > 0;
+	}
+	async mark(seedId) {
+		await this.ensureDeclared();
+		if (await this.has(seedId)) return;
+		await this.store.insert({
+			collection: BACKUP_SEED_MARKERS_COLLECTION,
+			record: {
+				id: seedId,
+				data: {
+					seed_id: seedId,
+					seeded_at: this.now()
+				}
+			}
+		});
+	}
+};
+//#endregion
 //#region ../../node_modules/croner/dist/croner.js
 function T(s) {
 	return Date.UTC(s.y, s.m - 1, s.d, s.h, s.i, s.s);
@@ -1277,7 +1409,8 @@ function normalizeManifest(raw) {
 			sizeBytes: Number(cand["sizeBytes"]),
 			...typeof cand["label"] === "string" ? { label: cand["label"] } : {},
 			manifest,
-			...encryptionOf(cand["encryption"])
+			...encryptionOf(cand["encryption"]),
+			...databasesOf(cand["databases"])
 		};
 		archives.push(entry);
 	}
@@ -1290,6 +1423,15 @@ var EMPTY_MANIFEST = {
 	version: 1,
 	archives: []
 };
+function databasesOf(raw) {
+	if (!Array.isArray(raw)) return {};
+	const known = [];
+	const unknown = [];
+	for (const item of raw) if (item === "settings" || item === "events" || item === "history") known.push(item);
+	else if (typeof item === "string") unknown.push(item);
+	if (known.length > 0) return { databases: known };
+	return unknown.length > 0 ? { unrecognisedDatabases: unknown } : {};
+}
 function encryptionOf(raw) {
 	if (typeof raw !== "object" || raw === null) return {};
 	const scheme = Reflect.get(raw, "scheme");
@@ -1313,7 +1455,8 @@ function outlineOfManifest(manifest) {
 		locations: [...manifest.locations],
 		entries: [],
 		totalBytes: manifest.totalBytes,
-		totalFiles: manifest.totalFiles
+		totalFiles: manifest.totalFiles,
+		...manifest.omittedDatabases !== void 0 ? { omittedDatabases: [...manifest.omittedDatabases] } : {}
 	};
 }
 /**
@@ -1329,9 +1472,15 @@ function buildArchiveEntry(input) {
 		sizeBytes: input.sizeBytes,
 		...input.label !== void 0 ? { label: input.label } : {},
 		manifest: input.encryption !== void 0 ? outlineOfManifest(input.manifest) : input.manifest,
-		...input.encryption !== void 0 ? { encryption: input.encryption } : {}
+		...input.encryption !== void 0 ? { encryption: input.encryption } : {},
+		...input.databases !== void 0 ? { databases: [...input.databases] } : {}
 	};
 }
+/** The key under which archives of one cadence prune each other. */
+function retentionClassOf(entry) {
+	if (entry.databases === void 0 && entry.unrecognisedDatabases !== void 0) return `?${[...entry.unrecognisedDatabases].toSorted().join("+")}`;
+	return [...entry.databases ?? require_restore_archive.DEFAULT_BACKUP_DATABASES].toSorted().join("+");
+}
 /**
 * Pure retention split: given an archive list and the operator's
 * `retentionCount`, return `{ keep, drop }` where `keep` is the most-
@@ -1340,20 +1489,27 @@ function buildArchiveEntry(input) {
 * `retentionCount <= 0` is treated as "no pruning" — defensive against
 * a config value that would otherwise wipe every archive on the next
 * write.
+*
+* `cadence` (see {@link retentionClassOf}) restricts the count to archives of
+* the run that was just written: nightly archives (settings) and weekly ones
+* (settings + events + history) are retained separately.
 */
-function applyRetention(archives, retentionCount) {
+function applyRetention(archives, retentionCount, cadence) {
 	if (retentionCount <= 0) return {
 		keep: archives,
 		drop: []
 	};
 	const sorted = [...archives].toSorted((a, b) => b.createdAt - a.createdAt);
-	if (sorted.length <= retentionCount) return {
+	const inCadence = cadence === void 0 ? sorted : sorted.filter((a) => retentionClassOf(a) === cadence);
+	if (inCadence.length <= retentionCount) return {
 		keep: sorted,
 		drop: []
 	};
+	const drop = inCadence.slice(retentionCount);
+	const dropped = new Set(drop);
 	return {
-		keep: sorted.slice(0, retentionCount),
-		drop: sorted.slice(retentionCount)
+		keep: sorted.filter((a) => !dropped.has(a)),
+		drop
 	};
 }
 /**
@@ -1637,7 +1793,8 @@ function requestSignature(request) {
 		destinations: [...request.destinations ?? []].toSorted(),
 		locations: [...request.locations ?? []].toSorted(),
 		label: request.label ?? null,
-		retentionCount: request.retentionCount ?? null
+		retentionCount: request.retentionCount ?? null,
+		databases: [...request.databases ?? []].toSorted()
 	});
 }
 //#endregion
@@ -1696,6 +1853,10 @@ var BACKUP_SCHEDULES_COLUMNS = [
 		name: "data_sources",
 		type: "JSON"
 	},
+	{
+		name: "databases",
+		type: "JSON"
+	},
 	{
 		name: "last_run_at",
 		type: "INTEGER"
@@ -1785,6 +1946,7 @@ function mapScheduleToRow(s) {
 		location_ids: [...s.locationIds],
 		retention_count: s.retentionCount,
 		data_sources: s.dataSources ? [...s.dataSources] : null,
+		databases: s.databases ? [...s.databases] : null,
 		last_run_at: s.lastAttemptAt ?? null,
 		last_success_at: s.lastSuccessAt ?? null,
 		last_error: s.lastError ?? null
@@ -1801,6 +1963,12 @@ function parseStringArray(raw) {
 	if (!Array.isArray(value)) return [];
 	return value.filter((v) => typeof v === "string");
 }
+/** Known database ids only: an unknown name in a stored row is dropped, not carried. */
+function parseDatabaseIds(raw) {
+	const out = [];
+	for (const id of parseStringArray(raw)) if (id === "settings" || id === "events" || id === "history") out.push(id);
+	return out;
+}
 function tryParseJson(raw) {
 	if (raw.length === 0) return null;
 	try {
@@ -1814,6 +1982,8 @@ function mapRowToSchedule(row) {
 	if (!id) return null;
 	const dataSourcesRaw = row["data_sources"];
 	const dataSources = dataSourcesRaw === null || dataSourcesRaw === void 0 ? void 0 : parseStringArray(dataSourcesRaw);
+	const databasesRaw = row["databases"];
+	const databases = databasesRaw === null || databasesRaw === void 0 ? void 0 : parseDatabaseIds(databasesRaw);
 	const lastRunRaw = row["last_run_at"];
 	const lastAttemptAt = typeof lastRunRaw === "number" && lastRunRaw > 0 ? lastRunRaw : void 0;
 	const lastSuccessRaw = row["last_success_at"];
@@ -1828,6 +1998,7 @@ function mapRowToSchedule(row) {
 		locationIds: parseStringArray(row["location_ids"]),
 		retentionCount: Number(row["retention_count"] ?? 7),
 		...dataSources !== void 0 ? { dataSources } : {},
+		...databases !== void 0 && databases.length > 0 ? { databases } : {},
 		...lastAttemptAt !== void 0 ? { lastAttemptAt } : {},
 		...lastSuccessAt !== void 0 ? { lastSuccessAt } : {},
 		...lastError !== void 0 ? { lastError } : {}
@@ -2080,6 +2251,7 @@ var BackupOrchestratorAddon = class extends require_dist.BaseAddon {
 			this.ctx.logger.error("backup-orchestrator: schedule table init failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
 			this.schedules = null;
 		}
+		await this.seedWeekly();
 		const settingsStore = this.ctx.kernel.capabilityRegistry?.getSingleton("settings-store");
 		this.encryptionKeys = settingsStore ? new BackupEncryptionKeyStore(settingsStore) : null;
 		const provider = {
@@ -2385,7 +2557,8 @@ var BackupOrchestratorAddon = class extends require_dist.BaseAddon {
 			...input?.destinations ? { destinations: input.destinations } : {},
 			...input?.locations ? { locations: input.locations } : {},
 			...input?.label !== void 0 ? { label: input.label } : {},
-			...input?.retentionCount !== void 0 ? { retentionCount: input.retentionCount } : {}
+			...input?.retentionCount !== void 0 ? { retentionCount: input.retentionCount } : {},
+			...input?.databases ? { databases: input.databases } : {}
 		};
 		const submitted = this.runQueue.submit(request);
 		if (submitted.queued) this.ctx.logger.info(submitted.joined ? "backup trigger: identical run already queued — joined it" : "backup trigger: a run is in flight — enqueued behind it", { meta: { runId: submitted.runId } });
@@ -2459,6 +2632,7 @@ var BackupOrchestratorAddon = class extends require_dist.BaseAddon {
 				signal,
 				onArchiveBytes: (bytes) => progress.setStagedBytes(bytes),
 				owner: this.databaseOwner(),
+				...input.databases ? { databases: input.databases } : {},
 				...encryptTo !== null ? { encryptTo: encryptTo.publicKey } : {}
 			});
 		} catch (err) {
@@ -2491,6 +2665,7 @@ var BackupOrchestratorAddon = class extends require_dist.BaseAddon {
 						sizeBytes: result.sizeBytes,
 						archiveManifest: result.manifest,
 						retentionCount: input.retentionCount ?? policy.retentionCount,
+						databases: input.databases ?? require_restore_archive.DEFAULT_BACKUP_DATABASES,
 						createdAt,
 						label: formatArchiveLabel(dest.id, createdAt, input.label),
 						...result.encryption !== void 0 ? { encryption: result.encryption } : {},
@@ -2562,9 +2737,9 @@ var BackupOrchestratorAddon = class extends require_dist.BaseAddon {
 		};
 		return {
 			listDatabases: async () => {
-				return (await this.ctx.api.databaseSnapshot.listDatabases.query({}, pin())).databases.map((d) => d.livePath);
+				return (await this.ctx.api.databaseSnapshot.listDatabases.query({}, pin())).databases;
 			},
-			writeSnapshot: async () => this.ctx.api.databaseSnapshot.writeSnapshot.mutate({}, pin())
+			writeSnapshot: async (databaseId) => this.ctx.api.databaseSnapshot.writeSnapshot.mutate({ databaseId }, pin())
 		};
 	}
 	/**
@@ -2616,10 +2791,11 @@ var BackupOrchestratorAddon = class extends require_dist.BaseAddon {
 			sizeBytes: input.sizeBytes,
 			label: input.label,
 			manifest: input.archiveManifest,
-			...input.encryption !== void 0 ? { encryption: input.encryption } : {}
+			...input.encryption !== void 0 ? { encryption: input.encryption } : {},
+			databases: input.databases
 		});
 		await this.manifestLock.run(input.locationId, async () => {
-			const { keep, drop } = applyRetention([...(await readLocationManifest(this.storageApi(), input.locationId)).archives, entry], input.retentionCount);
+			const { keep, drop } = applyRetention([...(await readLocationManifest(this.storageApi(), input.locationId)).archives, entry], input.retentionCount, retentionClassOf(entry));
 			for (const stale of drop) try {
 				await this.ctx.api.storage.delete.mutate({
 					location: input.locationId,
@@ -2673,7 +2849,8 @@ var BackupOrchestratorAddon = class extends require_dist.BaseAddon {
 			sizeBytes: a.sizeBytes,
 			...a.label !== void 0 ? { label: a.label } : {},
 			locations: [...a.manifest.locations],
-			...a.encryption !== void 0 ? { encryption: a.encryption } : {}
+			...a.encryption !== void 0 ? { encryption: a.encryption } : {},
+			...a.databases !== void 0 ? { databases: [...a.databases] } : {}
 		}));
 	}
 	/**
@@ -3040,6 +3217,55 @@ var BackupOrchestratorAddon = class extends require_dist.BaseAddon {
 		}
 	}
 	/**
+	* A schedule that asks for events/history while the owner has neither open
+	* would only repeat the nightly archive (D852: the weekly schedule has
+	* nothing to carry until those files exist). Said on the record, no archive
+	* built, no outcome stamped. An owner that cannot answer never skips: the
+	* run goes ahead and fails — or succeeds — in the open.
+	*/
+	async nothingToCarry(schedule) {
+		const requested = databasesOfSchedule(schedule);
+		if (!requested.some((id) => id !== "settings")) return false;
+		let owned;
+		try {
+			owned = (await this.databaseOwner().listDatabases()).map((d) => d.databaseId);
+		} catch (err) {
+			this.ctx.logger.warn("Scheduled backup: the database owner did not answer — running anyway", { meta: {
+				scheduleId: schedule.id,
+				label: schedule.label,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+			return false;
+		}
+		if (!hasNothingBeyondSettings(requested, owned)) return false;
+		this.ctx.logger.info("Scheduled backup skipped — no database it carries exists yet", { meta: {
+			scheduleId: schedule.id,
+			label: schedule.label,
+			requested: [...requested],
+			owned
+		} });
+		return true;
+	}
+	/**
+	* Seed the weekly "events & history" schedule (D852) — once, and never over
+	* anything the operator has: see `planWeeklySeed`.
+	*/
+	async seedWeekly() {
+		if (!this.schedules) return;
+		try {
+			const store = this.ctx.kernel.capabilityRegistry?.getSingleton("settings-store");
+			if (!store) return;
+			const seed = await seedWeeklySchedule(this.schedules, new BackupSeedMarkerStore(store));
+			if (seed === null) return;
+			this.ctx.logger.info("backup: seeded the weekly events & history schedule", { meta: {
+				scheduleId: seed.id,
+				destinationIds: [...seed.locationIds]
+			} });
+		} catch (err) {
+			this.ctx.logger.warn("backup: the weekly schedule could not be seeded", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		}
+	}
+	/**
 	* Fire one schedule and RECORD what happened to it, naming every
 	* destination. Three outcomes, three different persisted states —
 	* because "fired" and "backed up" were the same field until D384:
@@ -3050,13 +3276,15 @@ var BackupOrchestratorAddon = class extends require_dist.BaseAddon {
 	*/
 	async runScheduledBackup(schedule, firedAt) {
 		const destinationIds = [...schedule.locationIds];
+		if (await this.nothingToCarry(schedule)) return;
 		let failure;
 		try {
 			const result = await this.triggerBackup({
 				destinations: destinationIds,
 				...schedule.dataSources && schedule.dataSources.length > 0 ? { locations: [...schedule.dataSources] } : {},
 				label: schedule.label,
-				retentionCount: schedule.retentionCount
+				retentionCount: schedule.retentionCount,
+				...schedule.databases ? { databases: [...schedule.databases] } : {}
 			});
 			if (result.entries.length === 0 && !result.cancelled) failure = `no destination accepted the archive (${destinationIds.join(", ")})`;
 		} catch (err) {
@@ -3105,6 +3333,7 @@ var BackupOrchestratorAddon = class extends require_dist.BaseAddon {
 				locationIds: [...s.locationIds],
 				retentionCount: s.retentionCount,
 				...s.dataSources !== void 0 ? { dataSources: [...s.dataSources] } : {},
+				...s.databases !== void 0 ? { databases: [...s.databases] } : {},
 				...s.lastAttemptAt !== void 0 ? { lastAttemptAt: s.lastAttemptAt } : {},
 				...s.lastSuccessAt !== void 0 ? { lastSuccessAt: s.lastSuccessAt } : {},
 				...s.lastError !== void 0 ? { lastError: s.lastError } : {},
@@ -3126,6 +3355,7 @@ var BackupOrchestratorAddon = class extends require_dist.BaseAddon {
 			locationIds: [...input.locationIds],
 			retentionCount: input.retentionCount,
 			...input.dataSources && input.dataSources.length > 0 ? { dataSources: [...input.dataSources] } : {},
+			...input.databases && input.databases.length > 0 ? { databases: [...input.databases] } : {},
 			...existing?.lastAttemptAt !== void 0 ? { lastAttemptAt: existing.lastAttemptAt } : {},
 			...existing?.lastSuccessAt !== void 0 ? { lastSuccessAt: existing.lastSuccessAt } : {},
 			...existing?.lastError !== void 0 ? { lastError: existing.lastError } : {}
@@ -3144,6 +3374,7 @@ var BackupOrchestratorAddon = class extends require_dist.BaseAddon {
 			locationIds: [...next.locationIds],
 			retentionCount: next.retentionCount,
 			...next.dataSources !== void 0 ? { dataSources: [...next.dataSources] } : {},
+			...next.databases !== void 0 ? { databases: [...next.databases] } : {},
 			...next.lastAttemptAt !== void 0 ? { lastAttemptAt: next.lastAttemptAt } : {},
 			...next.lastSuccessAt !== void 0 ? { lastSuccessAt: next.lastSuccessAt } : {},
 			...next.lastError !== void 0 ? { lastError: next.lastError } : {},