@camstack/addon-post-analysis 1.2.366 → 1.2.368

package/dist/{clip-model-registry-CfYSfakK.js → clip-model-registry-cH-J5FCF.js}

@@ -14309,6 +14309,329 @@ method(object({
 	password: string()
 }), AuthResultSchema.nullable(), { kind: "mutation" }), method(object({ state: string() }), string()), method(record(string(), string()), AuthResultSchema, { kind: "mutation" }), method(object({ token: string() }), AuthResultSchema.nullable());
 /**
+* Query filter for settings-store collections.
+*/
+var QueryFilterSchema = object({
+	where: record(string(), unknown()).optional(),
+	whereIn: record(string(), array(unknown())).optional(),
+	whereBetween: record(string(), tuple([unknown(), unknown()])).optional(),
+	/** NULL-safe exclusion: matches rows whose field is NULL OR != the value. */
+	whereNot: record(string(), unknown()).optional(),
+	/** NULL-safe exclusion of a SET — `whereNot` for more than one value. An
+	*  empty list excludes nothing. See `QueryFilter.whereNotIn`. */
+	whereNotIn: record(string(), array(unknown())).optional(),
+	orderBy: object({
+		field: string(),
+		direction: _enum(["asc", "desc"])
+	}).optional(),
+	limit: number().optional(),
+	offset: number().optional()
+});
+/**
+* The predicate half of a filter, for BULK MUTATIONS.
+*
+* Deliberately not `QueryFilterSchema`: `orderBy` / `limit` / `offset` have no
+* meaning for a statement that rewrites a set, and accepting them would invite
+* a caller to believe `limit` bounds the damage. Every field is optional here
+* only so the shape stays composable — the implementation REJECTS a filter
+* that compiles to no predicate, because that is the whole collection.
+*/
+var MutationFilterSchema = object({
+	where: record(string(), unknown()).optional(),
+	whereIn: record(string(), array(unknown())).optional(),
+	whereBetween: record(string(), tuple([unknown(), unknown()])).optional(),
+	whereNot: record(string(), unknown()).optional(),
+	whereNotIn: record(string(), array(unknown())).optional()
+});
+/**
+* One scalar an {@link settingsStoreCapability.methods.aggregate} call asks for.
+*
+* `as` names the slot in the result, so the SAME column may be asked twice with
+* two operations (`MIN(startMs)` and `MAX(startMs)` in one round trip) — which
+* a `Record<column, op>` shape could not express.
+*/
+var AggregateFieldSchema = object({
+	/** Result key. */
+	as: string().min(1),
+	/** Column to aggregate. Must be a real column of a declared collection. */
+	field: string().min(1),
+	op: _enum([
+		"sum",
+		"min",
+		"max"
+	])
+});
+/**
+* `COUNT(*)` plus one number per requested field.
+*
+* `null` means NO ROW MATCHED, never zero: a `SUM` over an empty set and a sum
+* that really is 0 are different facts, and an accounting caller that renders
+* "0 bytes, oldest = 0" for "nothing here" reports a lie about a disk.
+*/
+var AggregateResultSchema = object({
+	count: number().int(),
+	values: record(string(), number().nullable())
+});
+/** A single stored record: `{ id, data }`. */
+var SettingsRecordSchema = object({
+	id: string(),
+	data: record(string(), unknown())
+});
+/**
+* One record of a BULK insert — {@link SettingsRecordSchema} with the id made
+* optional.
+*
+* A separate schema rather than loosening the shared one: every other method
+* on this cap addresses a row BY its id, and making that field optional
+* everywhere would turn a forgotten key into a silently generated one on
+* `update` and `delete` as well.
+*/
+var BulkRecordSchema = object({
+	id: string().optional(),
+	data: record(string(), unknown())
+});
+/**
+* The database FILES one `sqlite-settings` engine process owns (D851).
+* Closed on purpose: a file is a thing the engine opens, backs up and gives a
+* serving thread, so a new one is a code change, never a string a caller
+* invents. `settings` is `camstack.db` and the default for every collection
+* that names no file.
+*/
+var DataStoreDatabaseSchema = _enum([
+	"settings",
+	"events",
+	"history"
+]);
+DataStoreDatabaseSchema.options;
+/**
+* One write inside a {@link settingsStoreCapability.methods.transact} call.
+* The three that a "replace this set, bump that revision" write needs, plus
+* the batched upsert a rollup writer needs.
+*/
+var TransactOpSchema = discriminatedUnion("op", [
+	object({
+		op: literal("deleteWhere"),
+		collection: string(),
+		filter: MutationFilterSchema
+	}),
+	object({
+		op: literal("insertMany"),
+		collection: string(),
+		records: array(BulkRecordSchema).readonly()
+	}),
+	object({
+		op: literal("update"),
+		collection: string(),
+		id: string(),
+		data: record(string(), unknown())
+	}),
+	object({
+		op: literal("upsertMany"),
+		collection: string(),
+		conflict: array(string()).readonly(),
+		records: array(BulkRecordSchema).readonly()
+	})
+]);
+/**
+* The precondition of a transaction: the row `key` of `collection` must hold
+* `equals` in `column`, read INSIDE the transaction.
+*/
+var TransactGuardSchema = object({
+	collection: string(),
+	key: string(),
+	column: string(),
+	equals: unknown()
+});
+/**
+* Column declaration for a structured (SQL-backed) collection.
+*
+* Logical types — the backend translates each to the matching SQLite
+* storage class and handles per-type marshaling:
+*   - `TEXT` / `INTEGER` / `REAL` — native SQLite types, pass-through
+*   - `JSON`    — TEXT under the hood; serialised on write, parsed on read
+*   - `BOOLEAN` — INTEGER 0/1 under the hood; coerced both directions
+*/
+var CollectionColumnSchema = object({
+	name: string(),
+	type: _enum([
+		"TEXT",
+		"INTEGER",
+		"REAL",
+		"JSON",
+		"BOOLEAN"
+	]),
+	primaryKey: boolean().optional(),
+	notNull: boolean().optional(),
+	unique: boolean().optional(),
+	/**
+	* Column DEFAULT. Required for B2: the four `ensureTable` consumers declare
+	* columns like `enabled INTEGER NOT NULL DEFAULT 1`, and without this the
+	* collection surface simply cannot express their existing tables — which is
+	* why they were still on the uncapped `table*` API.
+	*/
+	defaultValue: union([
+		string(),
+		number(),
+		boolean()
+	]).optional()
+});
+var CollectionIndexSchema = object({
+	name: string(),
+	columns: array(string()).readonly(),
+	unique: boolean().optional()
+});
+/**
+* The input of `declareCollection` — ONE schema for the door and for the
+* engine behind it, so the two surfaces cannot drift (the dispatcher forwards
+* the payload untouched).
+*
+* - `database` — the file the collection lives in (D851). Absent means
+*   `settings`. A declaration naming a file other than the one the table is
+*   already in is REFUSED by the engine, never moved.
+* - `primaryKey` — a COMPOSITE key, as column names. A single name is the same
+*   as `primaryKey: true` on that column. A composite-keyed collection has no
+*   `id`: it is written with `insertMany` / `upsertMany` / `transact` and read
+*   with `query` / `count` / `aggregate` / `deleteWhere`; the calls that
+*   address one row by id are refused.
+* - `withoutRowid` — emit `WITHOUT ROWID`. Requires a primary key.
+*/
+var DeclareCollectionInputSchema = object({
+	namespace: string().optional(),
+	collection: string(),
+	columns: array(CollectionColumnSchema).readonly(),
+	indexes: array(CollectionIndexSchema).readonly().optional(),
+	database: DataStoreDatabaseSchema.optional(),
+	primaryKey: array(string()).readonly().optional(),
+	withoutRowid: boolean().optional()
+});
+method(object({
+	namespace: string().optional(),
+	collection: string(),
+	key: string()
+}), unknown(), { auth: "admin" }), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	key: string(),
+	value: unknown()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	filter: QueryFilterSchema.optional(),
+	columns: array(string()).readonly().optional()
+}), array(SettingsRecordSchema).readonly(), { auth: "admin" }), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	/** Declared columns identifying the slot; must be covered by a UNIQUE
+	*  index on the collection. Never empty. */
+	conflict: array(string()).readonly(),
+	record: BulkRecordSchema
+}), object({ 
+/** The id the row HAS: assigned by SQLite on an insert, or the existing
+*  row's own id on an update. */
+id: union([string(), number()]) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	conflict: array(string()).readonly(),
+	records: array(BulkRecordSchema).readonly()
+}), object({ upserted: number().int() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	record: object({
+		id: string().optional(),
+		data: record(string(), unknown())
+	})
+}), object({ 
+/**
+* The id the row ACTUALLY got (D473): the one supplied, the UUID minted
+* for an absent one, or the ROWID SQLite assigned on an `INTEGER`
+* primary key — which is the only place an auto key is knowable.
+*/
+id: union([string(), number()]) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	records: array(BulkRecordSchema).readonly()
+}), object({ inserted: number().int() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	namespace: string().optional(),
+	guard: TransactGuardSchema.optional(),
+	ops: array(TransactOpSchema).readonly()
+}), object({
+	applied: boolean(),
+	current: unknown().optional()
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	id: string(),
+	data: record(string(), unknown())
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	key: string()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	filter: MutationFilterSchema
+}), object({ deleted: number().int() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	filter: MutationFilterSchema,
+	data: record(string(), unknown())
+}), object({ updated: number().int() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	filter: QueryFilterSchema.optional()
+}), number(), { auth: "admin" }), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	fields: array(AggregateFieldSchema).readonly(),
+	filter: QueryFilterSchema.optional()
+}), AggregateResultSchema, { auth: "admin" }), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	field: string(),
+	bucketSize: number().int().positive(),
+	origin: number().int(),
+	filter: QueryFilterSchema.optional()
+}), array(object({
+	bucket: number().int(),
+	count: number().int()
+})).readonly(), { auth: "admin" }), method(object({
+	namespace: string().optional(),
+	collection: string()
+}), boolean(), { auth: "admin" }), method(DeclareCollectionInputSchema, _void(), {
+	kind: "mutation",
+	auth: "admin"
+});
+/**
 * How long one snapshot may take end to end: the pinned copy of the whole
 * database plus `PRAGMA integrity_check` over the copy, on the hub's slowest
 * disk. ~800 MB at a pessimistic 10 MB/s is under 3 minutes; the bound is
@@ -14321,7 +14644,11 @@ var DATABASE_SNAPSHOT_TIMEOUT_MS = 30 * 6e4;
 * database has no sidecars and is just as owned). Paths are absolute on the
 * owner's host.
 */
-var DatabaseSnapshotTargetsSchema = object({ databases: array(object({ livePath: string() })) });
+var DatabaseSnapshotTargetsSchema = object({ databases: array(object({
+	/** Which owned file this is — the handle `writeSnapshot` takes. */
+	databaseId: DataStoreDatabaseSchema,
+	livePath: string()
+})) });
 /** One b-tree table of the snapshot and the rows it holds. */
 var DatabaseSnapshotTableSchema = object({
 	name: string(),
@@ -14354,6 +14681,10 @@ var DatabaseSnapshotResultSchema = object({
 	/** When the pinned read transaction began (ms epoch) — the snapshot's instant. */
 	takenAt: number()
 });
+/** A snapshot the owner wrote, with the file it belongs to. */
+var DatabaseSnapshotWrittenSchema = DatabaseSnapshotResultSchema.extend({ databaseId: DataStoreDatabaseSchema });
+/** Which database `writeSnapshot` copies. Required: an unstated ask is not guessed. */
+var DatabaseSnapshotRequestSchema = object({ databaseId: DataStoreDatabaseSchema });
 /**
 * A snapshot as an ARCHIVE records it (`ArchiveManifest.sqliteSnapshots`):
 * the same facts, with both paths relative to the archive root (the node's
@@ -14363,9 +14694,11 @@ var ArchiveSqliteSnapshotSchema = DatabaseSnapshotResultSchema.extend({
 	/** Archive-relative path of the live database the archive does NOT carry. */
 	livePath: string(),
 	/** Archive-relative path of the verified copy it carries in its place. */
-	snapshotPath: string()
+	snapshotPath: string(),
+	/** Absent on an archive made before several files were owned: that was `settings`. */
+	databaseId: DataStoreDatabaseSchema.optional()
 });
-method(object({}), DatabaseSnapshotTargetsSchema, { auth: "admin" }), method(object({}), DatabaseSnapshotResultSchema, {
+method(object({}), DatabaseSnapshotTargetsSchema, { auth: "admin" }), method(DatabaseSnapshotRequestSchema, DatabaseSnapshotWrittenSchema, {
 	kind: "mutation",
 	auth: "admin",
 	timeoutMs: DATABASE_SNAPSHOT_TIMEOUT_MS
@@ -14486,7 +14819,12 @@ var BackupArchiveEntrySchema = object({
 	/** Top-level locations included in the archive (db, addons, tls, …). */
 	locations: array(string()).readonly(),
 	/** Present when the archive is encrypted; restore then needs that key. */
-	encryption: BackupArchiveEncryptionSchema.optional()
+	encryption: BackupArchiveEncryptionSchema.optional(),
+	/**
+	* The databases the run asked to carry (its retention class). Absent on an
+	* archive made before several files were owned: that was `['settings']`.
+	*/
+	databases: array(DataStoreDatabaseSchema).readonly().optional()
 });
 var BackupEntrySchema = object({
 	id: string(),
@@ -14520,7 +14858,12 @@ var ArchiveManifestSchema = object({
 	* Live SQLite databases this archive carries as their OWNER's verified
 	* snapshot instead of as files (D693). Absent on archives made before.
 	*/
-	sqliteSnapshots: array(ArchiveSqliteSnapshotSchema).optional()
+	sqliteSnapshots: array(ArchiveSqliteSnapshotSchema).optional(),
+	/**
+	* Owned database files the run did NOT carry (not selected): left out of the
+	* tar and the entry list alike. Absent when every owned file was carried.
+	*/
+	omittedDatabases: array(DataStoreDatabaseSchema).optional()
 });
 var LocationStatSchema = object({
 	name: string(),
@@ -14642,6 +14985,12 @@ var BackupScheduleSchema = object({
 	/** Optional subset of source locations to include; omitted = all. */
 	dataSources: array(string()).readonly().optional(),
 	/**
+	* Which database files this schedule carries. Absent = `['settings']`
+	* (an unstated ask is the minimum, D382). Events and history run weekly,
+	* settings nightly (D852).
+	*/
+	databases: array(DataStoreDatabaseSchema).readonly().optional(),
+	/**
 	* ms-epoch of the last tick that FIRED this schedule. Stamped before the
 	* archive runs (it is the dedupe anchor), so it says "attempted", never
 	* "succeeded" — a run refused by every destination stamps it too.
@@ -14665,7 +15014,9 @@ method(_void(), array(BackupDestinationInfoSchema).readonly(), { auth: "admin" }
 	* retention). Omitted = each destination's own policy
 	* retention (manual runs).
 	*/
-	retentionCount: number().int().min(1).max(1e3).optional()
+	retentionCount: number().int().min(1).max(1e3).optional(),
+	/** Database files to carry; omitted = `['settings']`. */
+	databases: array(DataStoreDatabaseSchema).optional()
 }).optional(), BackupTriggerResultSchema, {
 	kind: "mutation",
 	auth: "admin"
@@ -14740,14 +15091,18 @@ method(_void(), array(BackupDestinationInfoSchema).readonly(), { auth: "admin" }
 	ok: boolean(),
 	error: string().optional(),
 	nextRuns: array(number()).readonly()
-})), method(_void(), array(BackupScheduleSchema).readonly(), { auth: "admin" }), method(object({
+})), method(_void(), array(BackupScheduleSchema).readonly(), { auth: "admin" }), method(_void(), object({
+	answered: boolean(),
+	databases: array(DataStoreDatabaseSchema).readonly()
+}), { auth: "admin" }), method(object({
 	id: string().optional(),
 	label: string(),
 	cron: string(),
 	enabled: boolean(),
 	locationIds: array(string()).readonly(),
 	retentionCount: number().int().min(1).max(1e3),
-	dataSources: array(string()).readonly().optional()
+	dataSources: array(string()).readonly().optional(),
+	databases: array(DataStoreDatabaseSchema).readonly().optional()
 }), BackupScheduleSchema, {
 	kind: "mutation",
 	auth: "admin"
@@ -16527,282 +16882,6 @@ method(_void(), array(CustomModelDescriptorSchema).readonly(), { auth: "admin" }
 	timeoutMs: 30 * 6e4
 });
 /**
-* Query filter for settings-store collections.
-*/
-var QueryFilterSchema = object({
-	where: record(string(), unknown()).optional(),
-	whereIn: record(string(), array(unknown())).optional(),
-	whereBetween: record(string(), tuple([unknown(), unknown()])).optional(),
-	/** NULL-safe exclusion: matches rows whose field is NULL OR != the value. */
-	whereNot: record(string(), unknown()).optional(),
-	/** NULL-safe exclusion of a SET — `whereNot` for more than one value. An
-	*  empty list excludes nothing. See `QueryFilter.whereNotIn`. */
-	whereNotIn: record(string(), array(unknown())).optional(),
-	orderBy: object({
-		field: string(),
-		direction: _enum(["asc", "desc"])
-	}).optional(),
-	limit: number().optional(),
-	offset: number().optional()
-});
-/**
-* The predicate half of a filter, for BULK MUTATIONS.
-*
-* Deliberately not `QueryFilterSchema`: `orderBy` / `limit` / `offset` have no
-* meaning for a statement that rewrites a set, and accepting them would invite
-* a caller to believe `limit` bounds the damage. Every field is optional here
-* only so the shape stays composable — the implementation REJECTS a filter
-* that compiles to no predicate, because that is the whole collection.
-*/
-var MutationFilterSchema = object({
-	where: record(string(), unknown()).optional(),
-	whereIn: record(string(), array(unknown())).optional(),
-	whereBetween: record(string(), tuple([unknown(), unknown()])).optional(),
-	whereNot: record(string(), unknown()).optional(),
-	whereNotIn: record(string(), array(unknown())).optional()
-});
-/**
-* One scalar an {@link settingsStoreCapability.methods.aggregate} call asks for.
-*
-* `as` names the slot in the result, so the SAME column may be asked twice with
-* two operations (`MIN(startMs)` and `MAX(startMs)` in one round trip) — which
-* a `Record<column, op>` shape could not express.
-*/
-var AggregateFieldSchema = object({
-	/** Result key. */
-	as: string().min(1),
-	/** Column to aggregate. Must be a real column of a declared collection. */
-	field: string().min(1),
-	op: _enum([
-		"sum",
-		"min",
-		"max"
-	])
-});
-/**
-* `COUNT(*)` plus one number per requested field.
-*
-* `null` means NO ROW MATCHED, never zero: a `SUM` over an empty set and a sum
-* that really is 0 are different facts, and an accounting caller that renders
-* "0 bytes, oldest = 0" for "nothing here" reports a lie about a disk.
-*/
-var AggregateResultSchema = object({
-	count: number().int(),
-	values: record(string(), number().nullable())
-});
-/** A single stored record: `{ id, data }`. */
-var SettingsRecordSchema = object({
-	id: string(),
-	data: record(string(), unknown())
-});
-/**
-* One record of a BULK insert — {@link SettingsRecordSchema} with the id made
-* optional.
-*
-* A separate schema rather than loosening the shared one: every other method
-* on this cap addresses a row BY its id, and making that field optional
-* everywhere would turn a forgotten key into a silently generated one on
-* `update` and `delete` as well.
-*/
-var BulkRecordSchema = object({
-	id: string().optional(),
-	data: record(string(), unknown())
-});
-/**
-* One write inside a {@link settingsStoreCapability.methods.transact} call.
-* Only the three that a "replace this set, bump that revision" write needs.
-*/
-var TransactOpSchema = discriminatedUnion("op", [
-	object({
-		op: literal("deleteWhere"),
-		collection: string(),
-		filter: MutationFilterSchema
-	}),
-	object({
-		op: literal("insertMany"),
-		collection: string(),
-		records: array(BulkRecordSchema).readonly()
-	}),
-	object({
-		op: literal("update"),
-		collection: string(),
-		id: string(),
-		data: record(string(), unknown())
-	})
-]);
-/**
-* The precondition of a transaction: the row `key` of `collection` must hold
-* `equals` in `column`, read INSIDE the transaction.
-*/
-var TransactGuardSchema = object({
-	collection: string(),
-	key: string(),
-	column: string(),
-	equals: unknown()
-});
-/**
-* Column declaration for a structured (SQL-backed) collection.
-*
-* Logical types — the backend translates each to the matching SQLite
-* storage class and handles per-type marshaling:
-*   - `TEXT` / `INTEGER` / `REAL` — native SQLite types, pass-through
-*   - `JSON`    — TEXT under the hood; serialised on write, parsed on read
-*   - `BOOLEAN` — INTEGER 0/1 under the hood; coerced both directions
-*/
-var CollectionColumnSchema = object({
-	name: string(),
-	type: _enum([
-		"TEXT",
-		"INTEGER",
-		"REAL",
-		"JSON",
-		"BOOLEAN"
-	]),
-	primaryKey: boolean().optional(),
-	notNull: boolean().optional(),
-	unique: boolean().optional(),
-	/**
-	* Column DEFAULT. Required for B2: the four `ensureTable` consumers declare
-	* columns like `enabled INTEGER NOT NULL DEFAULT 1`, and without this the
-	* collection surface simply cannot express their existing tables — which is
-	* why they were still on the uncapped `table*` API.
-	*/
-	defaultValue: union([
-		string(),
-		number(),
-		boolean()
-	]).optional()
-});
-var CollectionIndexSchema = object({
-	name: string(),
-	columns: array(string()).readonly(),
-	unique: boolean().optional()
-});
-method(object({
-	namespace: string().optional(),
-	collection: string(),
-	key: string()
-}), unknown(), { auth: "admin" }), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	key: string(),
-	value: unknown()
-}), _void(), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	filter: QueryFilterSchema.optional(),
-	columns: array(string()).readonly().optional()
-}), array(SettingsRecordSchema).readonly(), { auth: "admin" }), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	/** Declared columns identifying the slot; must be covered by a UNIQUE
-	*  index on the collection. Never empty. */
-	conflict: array(string()).readonly(),
-	record: BulkRecordSchema
-}), object({ 
-/** The id the row HAS: assigned by SQLite on an insert, or the existing
-*  row's own id on an update. */
-id: union([string(), number()]) }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	record: object({
-		id: string().optional(),
-		data: record(string(), unknown())
-	})
-}), object({ 
-/**
-* The id the row ACTUALLY got (D473): the one supplied, the UUID minted
-* for an absent one, or the ROWID SQLite assigned on an `INTEGER`
-* primary key — which is the only place an auto key is knowable.
-*/
-id: union([string(), number()]) }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	records: array(BulkRecordSchema).readonly()
-}), object({ inserted: number().int() }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	namespace: string().optional(),
-	guard: TransactGuardSchema.optional(),
-	ops: array(TransactOpSchema).readonly()
-}), object({
-	applied: boolean(),
-	current: unknown().optional()
-}), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	id: string(),
-	data: record(string(), unknown())
-}), _void(), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	key: string()
-}), _void(), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	filter: MutationFilterSchema
-}), object({ deleted: number().int() }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	filter: MutationFilterSchema,
-	data: record(string(), unknown())
-}), object({ updated: number().int() }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	filter: QueryFilterSchema.optional()
-}), number(), { auth: "admin" }), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	fields: array(AggregateFieldSchema).readonly(),
-	filter: QueryFilterSchema.optional()
-}), AggregateResultSchema, { auth: "admin" }), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	field: string(),
-	bucketSize: number().int().positive(),
-	origin: number().int(),
-	filter: QueryFilterSchema.optional()
-}), array(object({
-	bucket: number().int(),
-	count: number().int()
-})).readonly(), { auth: "admin" }), method(object({
-	namespace: string().optional(),
-	collection: string()
-}), boolean(), { auth: "admin" }), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	columns: array(CollectionColumnSchema).readonly(),
-	indexes: array(CollectionIndexSchema).readonly().optional()
-}), _void(), {
-	kind: "mutation",
-	auth: "admin"
-});
-/**
 * What one engine says about itself. The orchestrator uses `kind` to pick
 * a registrant for a collection; `engineId` is what a log line names when
 * a call is routed or refused.
@@ -16882,6 +16961,14 @@ id: union([string(), number()]) }), {
 }), object({ id: union([string(), number()]) }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	conflict: array(string()).readonly(),
+	records: array(BulkRecordSchema).readonly()
+}), object({ upserted: number().int() }), {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({
 	namespace: string().optional(),
 	collection: string(),
@@ -16951,12 +17038,7 @@ id: union([string(), number()]) }), {
 })).readonly(), { auth: "admin" }), method(object({
 	namespace: string().optional(),
 	collection: string()
-}), boolean(), { auth: "admin" }), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	columns: array(CollectionColumnSchema).readonly(),
-	indexes: array(CollectionIndexSchema).readonly().optional()
-}), _void(), {
+}), boolean(), { auth: "admin" }), method(DeclareCollectionInputSchema, _void(), {
 	kind: "mutation",
 	auth: "admin"
 });
@@ -35762,6 +35844,18 @@ var CalendarInfoSchema = object({
 	source: CalendarSourceKindSchema,
 	enabled: boolean()
 });
+/**
+* Time contract of {@link CalendarEvent}.
+*
+* - Timed event: `startMs` / `endMs` are real instants; `endMs` is exclusive.
+* - All-day event (`allDay: true`): the event is a run of calendar DATES, not
+*   instants. `startMs` is UTC midnight of the first date and `endMs` is UTC
+*   midnight of the day AFTER the last date (RFC 5545 exclusive DTEND), so a
+*   one-day event spans exactly 24 h. Every provider produces that and no
+*   consumer may read the instants in a local timezone: use
+*   {@link calendarEventLocalSpan}. Reading UTC midnight as local time put an
+*   all-day event on the following day for any viewer ahead of UTC.
+*/
 var CalendarEventSchema = object({
 	id: string().min(1),
 	calendarId: string().min(1),
@@ -35778,6 +35872,33 @@ var CalendarListEventsInputSchema = object({
 	endMs: number().int()
 });
 method(_void(), array(CalendarInfoSchema).readonly(), { auth: "admin" }), method(CalendarListEventsInputSchema, array(CalendarEventSchema).readonly(), { auth: "admin" });
+function localMidnightOfUtcDate(utcMidnightMs) {
+	const d = new Date(utcMidnightMs);
+	return new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()).getTime();
+}
+/**
+* The interval an event occupies on the viewer's local clock, end exclusive.
+* A timed event is returned as is; an all-day event's UTC dates are re-read as
+* local calendar dates (local midnight to local midnight, DST-safe). A
+* degenerate all-day end (`<=` start) is widened to one day.
+*/
+function calendarEventLocalSpan(ev) {
+	if (ev.allDay !== true) return {
+		startMs: ev.startMs,
+		endMs: ev.endMs
+	};
+	const startMs = localMidnightOfUtcDate(ev.startMs);
+	const endMs = localMidnightOfUtcDate(ev.endMs);
+	if (endMs > startMs) return {
+		startMs,
+		endMs
+	};
+	const start = new Date(startMs);
+	return {
+		startMs,
+		endMs: new Date(start.getFullYear(), start.getMonth(), start.getDate() + 1).getTime()
+	};
+}
 /**
 * `calendars` — system-scoped singleton. Public surface admin-ui and the
 * notification-center calendar-events producer consume.
@@ -38811,7 +38932,15 @@ var HubAddressBookSchema = object({
 		publicEndpoint: HubAddressRoleResolutionSchema
 	}),
 	/** The `hub=` an app link carries (D709), or null. */
-	appLinkHub: string().nullable()
+	appLinkHub: string().nullable(),
+	/**
+	* Every origin a browser can really reach this hub at, in the scheme each
+	* listener serves: `https://<lan>:<httpsPort>`, and `http://<lan>:<httpPort>`
+	* while LAN HTTP is on, plus the public and custom addresses. Distinct from
+	* `rows`, which show `http://` only while LAN HTTP is on. Never loopback,
+	* never the app link. Absent on a hub older than D794's amendment.
+	*/
+	listenerOrigins: array(string()).readonly().optional()
 });
 var AllowedAddressesSchema = object({ 
 /**
@@ -48385,6 +48514,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"backup.listAvailableDatabases": {
+		capName: "backup",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"backup.listDestinations": {
 		capName: "backup",
 		capScope: "system",
@@ -49105,6 +49240,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"dataStoreProvider.upsertMany": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"dayNight.getOptions": {
 		capName: "day-night",
 		capScope: "device",
@@ -53953,6 +54094,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"settingsStore.upsertMany": {
+		capName: "settings-store",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"smoke.getStatus": {
 		capName: "smoke",
 		capScope: "device",
@@ -64487,6 +64634,12 @@ Object.defineProperty(exports, "buildViewerLink", {
 		return buildViewerLink;
 	}
 });
+Object.defineProperty(exports, "calendarEventLocalSpan", {
+	enumerable: true,
+	get: function() {
+		return calendarEventLocalSpan;
+	}
+});
 Object.defineProperty(exports, "canonicalHash", {
 	enumerable: true,
 	get: function() {