@camstack/addon-google-services 0.2.39 → 0.2.40

package/dist/google-services.addon.mjs

@@ -1,4 +1,4 @@
-import { randomBytes } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 //#region ../types/dist/event-category-BmPm98n0.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
@@ -13517,6 +13517,39 @@ function buildCapturingReply(envelope) {
 	return wrapper;
 }
 /**
+* The link primitive's declaration half (D1013 rule 5): what a link field names and how a kind
+* records it. Split from `instance-link.ts` so `RecordIntegrationInstances` can read the links of
+* its kind without importing the builders that import it.
+*/
+/** The body field of a link: the id of the instance it names; the target rides in the field meta. */
+function linkField(target) {
+	return string().meta({ link: target });
+}
+function linkTargetOf(meta) {
+	if (typeof meta !== "object" || meta === null) return void 0;
+	const link = Reflect.get(meta, "link");
+	const parsed = LinkTargetSchema.safeParse(link);
+	return parsed.success ? parsed.data : void 0;
+}
+var LinkTargetSchema = object({
+	cap: string().min(1),
+	kind: string().min(1).optional()
+});
+/** The links a kind declares, read from the meta of its body fields. */
+function linksOfKind(kind) {
+	const schema = kind.schema;
+	if (!(schema instanceof ZodObject)) return [];
+	const links = [];
+	for (const [field, fieldSchema] of Object.entries(schema.shape)) {
+		const to = linkTargetOf(globalRegistry.get(fieldSchema));
+		if (to !== void 0) links.push({
+			field,
+			to
+		});
+	}
+	return links;
+}
+/**
 * `RecordIntegrationInstances` - the `integration-instances` provider over ONE
 * entry kind, so an addon that holds a connection serves it in ~30 lines.
 *
@@ -13637,9 +13670,18 @@ var RecordIntegrationInstances = class {
 			...health?.lastCheckedAt !== void 0 ? { lastCheckedAt: health.lastCheckedAt } : {}
 		};
 	}
-	describe = async () => this.hooks.mintId === void 0 ? this.hooks.description : {
-		...this.hooks.description,
-		mintsId: true
+	describe = async () => {
+		const declared = linksOfKind(this.kind);
+		const links = this.hooks.description.links !== void 0 || declared.length === 0 ? {} : { links: declared.map((link) => ({
+			kind: this.kind.name,
+			field: link.field,
+			to: link.to
+		})) };
+		return {
+			...this.hooks.description,
+			...links,
+			...this.hooks.mintId === void 0 ? {} : { mintsId: true }
+		};
 	};
 	instanceFormSchema = async ({ id }) => this.hooks.formSchema(id);
 	listInstances = async () => {
@@ -13722,6 +13764,80 @@ var RecordIntegrationInstances = class {
 		};
 	}
 };
+/** No part holds the id a call named. */
+var UnknownInstanceError = class extends Error {
+	instanceId;
+	constructor(instanceId) {
+		super(`Unknown instance '${instanceId}'`);
+		this.instanceId = instanceId;
+		this.name = "UnknownInstanceError";
+	}
+};
+/** A create or a form named no kind, or a kind no part serves. */
+var UnknownInstanceKindError = class extends Error {
+	kindId;
+	constructor(kindId) {
+		super(kindId === void 0 ? "This provider has several kinds: name one" : `Unknown instance kind '${kindId}'`);
+		this.kindId = kindId;
+		this.name = "UnknownInstanceKindError";
+	}
+};
+function composeInstanceKinds(parts, base) {
+	const byKind = (kindId) => {
+		if (kindId === void 0) {
+			const only = parts.length === 1 ? parts[0] : void 0;
+			if (only === void 0) throw new UnknownInstanceKindError(void 0);
+			return only;
+		}
+		const part = parts.find((candidate) => candidate.kind.id === kindId);
+		if (part === void 0) throw new UnknownInstanceKindError(kindId);
+		return part;
+	};
+	const holderOf = async (id) => {
+		for (const part of parts) if (await part.provider.getInstance({ id }) !== null) return part;
+		throw new UnknownInstanceError(id);
+	};
+	const tagged = (part, instance) => ({
+		...instance,
+		kind: part.kind.id
+	});
+	return {
+		describe: async () => {
+			const links = (await Promise.all(parts.map(async (part) => (await part.provider.describe()).links ?? []))).flat();
+			return {
+				...base,
+				kinds: parts.map((part) => part.kind),
+				...links.length > 0 ? { links } : {}
+			};
+		},
+		instanceFormSchema: async ({ id, kind }) => {
+			return (id === null ? byKind(kind) : await holderOf(id)).provider.instanceFormSchema({ id });
+		},
+		listInstances: async () => {
+			return (await Promise.all(parts.map(async (part) => (await part.provider.listInstances()).map((instance) => tagged(part, instance))))).flat();
+		},
+		getInstance: async ({ id }) => {
+			for (const part of parts) {
+				const found = await part.provider.getInstance({ id });
+				if (found !== null) return tagged(part, found);
+			}
+			return null;
+		},
+		createInstance: async (input) => byKind(input.kind).provider.createInstance(input),
+		updateInstance: async (input) => (await holderOf(input.id)).provider.updateInstance(input),
+		setInstanceEnabled: async (input) => (await holderOf(input.id)).provider.setInstanceEnabled(input),
+		deleteInstance: async (input) => (await holderOf(input.id)).provider.deleteInstance(input),
+		testInstance: async (input) => {
+			const test = (input.id === null ? byKind(input.kind) : await holderOf(input.id)).provider.testInstance;
+			if (test === void 0) return {
+				success: false,
+				status: "inconclusive",
+				error: "This kind cannot be tested"
+			};
+			return test(input);
+		}
+	};
+}
 var EncodeProfileSchema = object({
 	video: object({
 		codec: _enum([
@@ -54207,18 +54323,38 @@ var IntegrationInstanceKindSchema = object({
 	/** Relative hub path to disconnect that account. */
 	disconnectPath: string().min(1).optional()
 });
+/**
+* How devices of an instance are found. `none`: the operator adds them by hand; `lan`: the addon
+* scans the network before any instance exists (the wizard offers the candidates); `account`: the
+* devices appear after the instance signs in. `scopedToInstance`: a discovery run belongs to ONE
+* instance and its candidates are claimed by it.
+*/
+var IntegrationInstanceDiscoverySchema = object({
+	mode: _enum([
+		"none",
+		"lan",
+		"account"
+	]),
+	scopedToInstance: boolean()
+});
+/**
+* One link a kind of this provider declares (D1013 rule 5): the body `field` of an instance of
+* `kind` holds the id of an instance of the function cap `to.cap` (of kind `to.kind`, when set).
+* The hub indexes these so the target's delete is refused while a link names it.
+*/
+var IntegrationInstanceLinkSchema = object({
+	kind: string().min(1),
+	field: string().min(1),
+	to: object({
+		cap: string().min(1),
+		kind: string().min(1).optional()
+	})
+});
 var IntegrationInstanceDescriptionSchema = object({
 	/** What the instances are for the Integrations page; see {@link IntegrationInstanceRoleSchema}. */
 	role: IntegrationInstanceRoleSchema,
 	/** How the devices of an instance are found; absent means `{ mode: 'none' }`. */
-	discovery: object({
-		mode: _enum([
-			"none",
-			"lan",
-			"account"
-		]),
-		scopedToInstance: boolean()
-	}).optional(),
+	discovery: IntegrationInstanceDiscoverySchema.optional(),
 	/** `single`: at most one instance can exist (Loki). `multiple`: an account each. */
 	instanceMode: IntegrationInstanceModeSchema,
 	/** What the instance is, for the UI (`destination`, `relay`, `account`). */
@@ -54239,7 +54375,9 @@ var IntegrationInstanceDescriptionSchema = object({
 	* `createInstance` without an `id` works: the provider mints it. Absent means the caller must
 	* send an id (the UI then mints an opaque one).
 	*/
-	mintsId: boolean().optional()
+	mintsId: boolean().optional(),
+	/** The links to other instances the provider's kinds declare; absent means none. */
+	links: array(IntegrationInstanceLinkSchema).optional()
 });
 var IntegrationInstanceStatusSchema = object({
 	state: _enum([
@@ -91230,7 +91368,165 @@ object({
 	delay: number().nonnegative().optional(),
 	commands: record(string(), unknown())
 });
+/** The `instance-select` field of a link, keyed like the body field it fills. */
+function linkFieldDescriptor(key, target, labels) {
+	return {
+		type: "instance-select",
+		key,
+		label: labels.label,
+		...labels.description !== void 0 ? { description: labels.description } : {},
+		required: labels.required ?? true,
+		...labels.noneLabel !== void 0 ? { noneLabel: labels.noneLabel } : {},
+		functionCap: target.cap,
+		...target.kind !== void 0 ? { kind: target.kind } : {}
+	};
+}
+/**
+* Declare the record kind of a service that links to other instances. The body is
+* `{ name, ...links, ...fields }`; the links are recorded in the kind (read back by
+* {@link linksOfKind}) so the hub can index who points at what.
+*/
+function declareLinkKind(spec) {
+	const linkShape = {};
+	for (const [field, target] of Object.entries(spec.links)) linkShape[field] = linkField(target);
+	const typed = entryBody({
+		...linkShape,
+		...spec.fields
+	});
+	return defineEntryKind(spec.name, {
+		title: spec.title,
+		schema: typed,
+		writeTrigger: spec.writeTrigger
+	});
+}
+/** The id a record holds in a link field; undefined while it names none. */
+function linkedId(body, field) {
+	const value = body[field];
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+/** The `integration-instances` provider of a service whose records link to other instances. */
+function buildLinkedInstances(records, spec) {
+	const links = linksOfKind(spec.kind);
+	const kindId = spec.instanceKind ?? spec.kind.name;
+	const instances = new RecordIntegrationInstances(records, spec.kind, {
+		description: {
+			...spec.description,
+			links: links.map((link) => ({
+				kind: kindId,
+				field: link.field,
+				to: link.to
+			}))
+		},
+		formSchema: async (id) => {
+			const first = links[0];
+			const chosen = id === null || first === void 0 || spec.dynamicSections === void 0 ? void 0 : linkedId(await instances.getResolved(id) ?? {}, first.field);
+			const dynamic = chosen !== void 0 && spec.dynamicSections !== void 0 ? await spec.dynamicSections(chosen) : [];
+			return { sections: [
+				{
+					id: "links",
+					title: "Linked instances",
+					columns: 1,
+					fields: links.map((link) => linkFieldDescriptor(link.field, link.to, spec.labels?.[link.field] ?? { label: link.field }))
+				},
+				...spec.linkSections ?? [],
+				...dynamic
+			] };
+		},
+		initialBody: (name) => spec.kind.schema.parse({
+			name,
+			...Object.fromEntries(links.map((link) => [link.field, ""]))
+		}),
+		configured: (body) => links.every((link) => linkedId(body, link.field) !== void 0) && (spec.alsoConfigured?.(body) ?? true),
+		...spec.mintId !== void 0 ? { mintId: spec.mintId } : {},
+		...spec.onChanged !== void 0 ? { onChanged: spec.onChanged } : {}
+	});
+	return instances;
+}
 entryBody({ brokerId: string() });
+/**
+* The calendars an account imports leave the account (D1013). An account record used to carry a
+* `calendarIds` array; each calendar is now a record of its own that LINKS to the account
+* (`calendars`, one per account and calendar). For every account row with an array:
+*
+*  1. each entry becomes a calendar record under a deterministic id (an existing one is kept);
+*  2. each record is read back and must name this account and calendar;
+*  3. only then is the array cleared (a patch: nothing else on the account is touched).
+*
+* An entry that names another account, or is not a calendar id at all, selected nothing before
+* (the reader only matched its own account's ids): it is counted, named in a warning and goes with
+* the array. An array that is not a list of strings is left where it is. A failure on one account
+* does not stop the others; the run then throws, and the accounts that failed keep their array.
+* Accounts are never created or deleted. Idempotent: with the arrays cleared nothing is left to do.
+*/
+/** The id of the calendar record of one (account, calendar): the same pair is always the same row. */
+function calendarRecordId(accountId, calendarId) {
+	return `cal_${createHash("sha1").update(`${accountId}\0${calendarId}`).digest("hex").slice(0, 16)}`;
+}
+function entriesOf(value) {
+	if (!Array.isArray(value)) return null;
+	const out = [];
+	for (const item of value) {
+		if (typeof item !== "string") return null;
+		out.push(item);
+	}
+	return out;
+}
+async function moveCalendarIdsToRecords(ports, spec) {
+	let created = 0;
+	let cleared = 0;
+	let dropped = 0;
+	const failed = [];
+	for (const account of await ports.listAccounts()) {
+		if (account.calendarIds === void 0 || account.calendarIds === null) continue;
+		const entries = entriesOf(account.calendarIds);
+		if (entries === null) {
+			ports.warn(`account '${account.id}': calendarIds is not a list of ids and stays as it is`);
+			failed.push(account.id);
+			continue;
+		}
+		try {
+			const own = /* @__PURE__ */ new Set();
+			const inert = [];
+			for (const entry of entries) {
+				const calendarId = spec.calendarIdOf(account.id, entry);
+				if (calendarId === null || calendarId === "") inert.push(entry);
+				else own.add(calendarId);
+			}
+			for (const calendarId of own) {
+				const recordId = calendarRecordId(account.id, calendarId);
+				const body = {
+					name: calendarId,
+					accountId: account.id,
+					calendarId
+				};
+				if (await ports.readCalendar(recordId) === null) {
+					await ports.putCalendar(recordId, body);
+					created += 1;
+				}
+				const back = await ports.readCalendar(recordId);
+				if (back?.accountId !== account.id || back.calendarId !== calendarId) throw new Error(`account '${account.id}': the calendar record '${recordId}' did not read back; the array stays`);
+			}
+			if (inert.length > 0) {
+				ports.warn(`account '${account.id}': ${inert.length} entr${inert.length === 1 ? "y" : "ies"} of calendarIds named another account or no calendar and selected nothing: ${inert.join(", ")}`);
+				dropped += inert.length;
+			}
+			await ports.clearCalendarIds(account.id);
+			cleared += 1;
+		} catch (error) {
+			ports.warn(error instanceof Error ? error.message : String(error));
+			failed.push(account.id);
+		}
+	}
+	if (failed.length > 0) throw new Error(`calendarIds kept on ${failed.length} account(s) (${failed.join(", ")}); ${created} calendar record(s) written, ${cleared} account(s) cleared`);
+	return {
+		outcome: created === 0 && cleared === 0 ? "already-done" : "done",
+		summary: {
+			created,
+			cleared,
+			dropped
+		}
+	};
+}
 //#endregion
 //#region src/google-types.ts
 /** One Google account connection (broker entry). Credentials for the OAuth
@@ -91241,28 +91537,16 @@ var GoogleBrokerEntrySchema = object({
 	clientId: string().default(""),
 	clientSecret: string().default("").meta({ secret: true }),
 	/**
-	* @deprecated Per-broker filter; import selection lives on addon
-	* `calendarIds` (Connectivity → Calendars). Kept for migrate only.
+	* @deprecated Per-broker filter; the calendars an account imports are `calendars` records
+	* (Connectivity → Calendars). Kept for migrate only.
 	*/
 	calendarFilter: string().default(""),
 	/** Default From for Gmail send — usually the connected account email. */
 	fromAddress: string().default(""),
-	fromName: string().default(""),
-	/**
-	* The stamped calendar ids (`<brokerId>:<googleCalendarId>`) this broker imports. `undefined`
-	* means "not moved here yet": the reader falls back to the shared `calendarIds` setting of
-	* the addon until the migration copied it. Empty = import none.
-	*/
-	calendarIds: array(string()).optional()
+	fromName: string().default("")
 });
 var GoogleServicesConfigSchema = object({
 	brokers: array(GoogleBrokerEntrySchema).default([]),
-	/**
-	* @deprecated The shared set (`brokerId:googleCalendarId`). Each broker owns its own
-	* `calendarIds` now; this key is read only while a broker has none, and the migration
-	* `google-services/2026-11-03-drop-shared-calendar-ids` deletes it.
-	*/
-	calendarIds: array(string()).default([]),
 	/** @deprecated Pre-broker singleton — cleared after migrateLegacyToBrokers. */
 	clientId: string().optional(),
 	/** @deprecated Pre-broker singleton — cleared after migrateLegacyToBrokers. */
@@ -91323,34 +91607,25 @@ var OAUTH_CALLBACK_SUFFIX = `/addon/google-services/oauth/callback`;
 var GoogleAddSettingsSchema = object({
 	clientId: string().min(1),
 	clientSecret: string().min(1).meta({ secret: true }),
-	/** Selected Google calendar ids; empty = import all. */
-	calendarIds: array(string()).optional(),
-	/** @deprecated Prefer calendarIds — still accepted on save. */
+	/** @deprecated Calendars are `calendars` records now — still accepted on save. */
 	calendarFilter: string().optional(),
 	fromAddress: string().optional(),
 	fromName: string().optional()
 });
-/** Persist UI calendarIds (or legacy filter string) as comma-separated filter. */
-function calendarIdsToFilter(settings) {
-	if (settings.calendarIds !== void 0) return settings.calendarIds.map((s) => s.trim()).filter((s) => s.length > 0).join(",");
-	return settings.calendarFilter ?? "";
-}
 function settingsToBrokerFields(settings) {
 	const parsed = GoogleAddSettingsSchema.parse(settings);
 	return {
 		clientId: parsed.clientId,
 		clientSecret: parsed.clientSecret,
-		calendarFilter: calendarIdsToFilter(parsed),
+		calendarFilter: parsed.calendarFilter ?? "",
 		fromAddress: parsed.fromAddress ?? "",
-		fromName: parsed.fromName ?? "",
-		...parsed.calendarIds !== void 0 ? { calendarIds: [...parsed.calendarIds] } : {}
+		fromName: parsed.fromName ?? ""
 	};
 }
 function brokerEntryToSettings(entry) {
 	return {
 		clientId: entry.clientId,
 		clientSecret: entry.clientSecret,
-		calendarIds: [...entry.calendarIds ?? parseCalendarFilter(entry.calendarFilter)],
 		fromAddress: entry.fromAddress,
 		fromName: entry.fromName
 	};
@@ -91401,18 +91676,6 @@ function migrateLegacyToBrokers(rawConfig, legacyOauth) {
 		didMigrate: true
 	};
 }
-/**
-* The stamped calendar ids one broker imports: its own set, or — while the migration has not
-* reached it — the shared setting older versions wrote, so the move never changes what is imported.
-*/
-function calendarIdsOfEntry(entry, shared) {
-	return new Set(entry?.calendarIds ?? shared);
-}
-function parseCalendarFilter(raw) {
-	const trimmed = raw.trim();
-	if (!trimmed) return /* @__PURE__ */ new Set();
-	return new Set(trimmed.split(",").map((s) => s.trim()).filter((s) => s.length > 0));
-}
 /** Local calendar id stamped as `brokerId:googleCalendarId`. */
 function stampCalendarId(brokerId, googleCalendarId) {
 	return `${brokerId}:${googleCalendarId}`;
@@ -91494,7 +91757,6 @@ var GoogleBrokerRegistry = class {
 		const entry = GoogleBrokerEntrySchema.parse({
 			id,
 			name,
-			calendarIds: [],
 			...fields
 		});
 		this.entries = [...this.entries, entry];
@@ -91508,7 +91770,6 @@ var GoogleBrokerRegistry = class {
 		const next = GoogleBrokerEntrySchema.parse({
 			id: prev.id,
 			name: prev.name,
-			...prev.calendarIds !== void 0 ? { calendarIds: prev.calendarIds } : {},
 			...fields
 		});
 		this.entries = this.entries.map((e, i) => i === idx ? next : e);
@@ -91530,11 +91791,8 @@ var GoogleBrokerRegistry = class {
 	connectedSize() {
 		return this.entries.filter((e) => this.isConnected(e.id)).length;
 	}
-	toConfig(calendarIds = []) {
-		return {
-			brokers: [...this.entries],
-			calendarIds: [...calendarIds]
-		};
+	toConfig() {
+		return { brokers: [...this.entries] };
 	}
 	seedCounterFromEntries(entries) {
 		let maxSeen = 0;
@@ -91692,24 +91950,6 @@ function buildGoogleBrokerSettingsSchema(publicOrigin) {
 				showToggle: true
 			}]
 		},
-		{
-			id: "google-calendars-import",
-			title: "Calendars to import",
-			titleKey: "google-services:googleBrokerSettings.s_google-calendars-import.title",
-			description: "Nothing selected = no calendars imported from this account. Options appear once the account is signed in.",
-			descriptionKey: "google-services:googleBrokerSettings.s_google-calendars-import.description",
-			columns: 1,
-			fields: [{
-				type: "multiselect",
-				key: "calendarIds",
-				label: "Calendars",
-				labelKey: "google-services:googleBrokerSettings.s_google-calendars-import.calendarIds.label",
-				options: [],
-				optionsFrom: "_calendarCatalog",
-				description: "The calendars of this Google account that CamStack imports.",
-				descriptionKey: "google-services:googleBrokerSettings.s_google-calendars-import.calendarIds.description"
-			}]
-		},
 		{
 			id: "gmail-send",
 			title: "Gmail send",
@@ -91749,7 +91989,7 @@ function buildGoogleFeatureSettingsSchema(cap, publicOrigin) {
 			format: "html",
 			content: [
 				"<p>Link a Google account under Connectivity → <strong>Brokers</strong> ",
-				"(Client ID / secret + Sign in). Pick the calendars to import on each broker. ",
+				"(Client ID / secret + Sign in), then add a calendar under Connectivity → <strong>Calendars</strong>. ",
 				`OAuth redirect URI: <code>${redirect}</code>.</p>`
 			].join("")
 		}]
@@ -92229,11 +92469,76 @@ var googleBrokersEntryKind = defineEntryKind("brokers", {
 		clientSecret: GoogleBrokerEntrySchema.shape.clientSecret,
 		calendarFilter: GoogleBrokerEntrySchema.shape.calendarFilter,
 		fromAddress: GoogleBrokerEntrySchema.shape.fromAddress,
-		fromName: GoogleBrokerEntrySchema.shape.fromName,
-		calendarIds: GoogleBrokerEntrySchema.shape.calendarIds
+		fromName: GoogleBrokerEntrySchema.shape.fromName
 	}),
 	writeTrigger: "an operator adds or edits a Google OAuth broker"
 });
+/**
+* One calendar an account imports (D1013): a record that LINKS to the account it belongs to and
+* names the Google calendar by its own id (`primary`, `name@group.calendar.google.com`). The id the
+* calendar answers to elsewhere stays `<accountId>:<calendarId>` (`stampCalendarId`).
+*/
+var googleCalendarsEntryKind = declareLinkKind({
+	name: "calendars",
+	title: "Google calendars",
+	writeTrigger: "an operator adds or removes a calendar an account imports",
+	links: { accountId: {
+		cap: "broker",
+		kind: GOOGLE_BROKER_KIND
+	} },
+	fields: { calendarId: string().default("") }
+});
+//#endregion
+//#region src/google-calendar-instances.ts
+/**
+* The calendars a Google account imports as `integration-instances` (D1013): one `calendars`
+* record per (account, calendar), linking to its account through the link primitive. The calendar
+* source reads the records; nothing is stored on the account.
+*/
+var GOOGLE_CALENDAR_INSTANCE_KIND = "calendar";
+/** The stamped ids each account imports, from the calendar records. */
+function selectedStampedIds(rows) {
+	const out = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const { accountId, calendarId } = row.body;
+		if (!row.enabled || accountId === "" || calendarId === "") continue;
+		const set = out.get(accountId) ?? /* @__PURE__ */ new Set();
+		set.add(stampCalendarId(accountId, calendarId));
+		out.set(accountId, set);
+	}
+	return out;
+}
+function buildGoogleCalendarInstances(records, deps) {
+	return buildLinkedInstances(records, {
+		kind: googleCalendarsEntryKind,
+		instanceKind: GOOGLE_CALENDAR_INSTANCE_KIND,
+		description: {
+			role: "services",
+			instanceMode: "multiple",
+			kind: GOOGLE_CALENDAR_INSTANCE_KIND,
+			canTest: false
+		},
+		labels: { accountId: {
+			label: "Google account",
+			description: "The account this calendar belongs to."
+		} },
+		alsoConfigured: (body) => body.calendarId !== "",
+		dynamicSections: async (accountId) => [{
+			id: "google-calendar-pick",
+			title: "Calendar",
+			columns: 1,
+			fields: [{
+				type: "select",
+				key: "calendarId",
+				label: "Calendar",
+				options: [...await deps.catalog(accountId)],
+				description: "The calendars of that account. Sign the account in to see them."
+			}]
+		}],
+		mintId: () => `cal_${randomBytes(6).toString("hex")}`,
+		onChanged: deps.onChanged
+	});
+}
 //#endregion
 //#region src/google-instances.ts
 /**
@@ -92253,6 +92558,17 @@ function asTestResult(r) {
 		error: r.error ?? "Google rejected the check"
 	};
 }
+/** The `account` kind of the composed provider: where the OAuth sign-in starts and ends. */
+function googleAccountKind(deps) {
+	return {
+		id: GOOGLE_BROKER_KIND,
+		label: GOOGLE_BROKER_KIND_LABEL,
+		functionCap: "broker",
+		brokerKind: GOOGLE_BROKER_KIND,
+		connectPath: deps.connectPath,
+		disconnectPath: deps.disconnectPath
+	};
+}
 function buildGoogleInstances(records, deps) {
 	return new RecordIntegrationInstances(records, googleBrokersEntryKind, {
 		description: {
@@ -92260,31 +92576,16 @@ function buildGoogleInstances(records, deps) {
 			instanceMode: "multiple",
 			kind: "account",
 			canTest: true,
-			kinds: [{
-				id: GOOGLE_BROKER_KIND,
-				label: GOOGLE_BROKER_KIND_LABEL,
-				functionCap: "broker",
-				brokerKind: GOOGLE_BROKER_KIND,
-				connectPath: deps.connectPath,
-				disconnectPath: deps.disconnectPath
-			}],
 			allowRestoreId: true
 		},
-		formSchema: () => {
-			const full = buildGoogleBrokerSettingsSchema(deps.publicOrigin());
-			return {
-				...full,
-				sections: full.sections.filter((s) => s.id !== "google-calendars-import")
-			};
-		},
+		formSchema: () => buildGoogleBrokerSettingsSchema(deps.publicOrigin()),
 		initialBody: (name) => ({
 			name,
 			clientId: "",
 			clientSecret: "",
 			calendarFilter: "",
 			fromAddress: "",
-			fromName: "",
-			calendarIds: []
+			fromName: ""
 		}),
 		mintId: deps.mintId,
 		kindOf: () => GOOGLE_BROKER_KIND,
@@ -92403,42 +92704,66 @@ async function planDropSharedCalendarIds(ports) {
 		} })
 	}] };
 }
-//#endregion
-//#region src/migrations/index.ts
 /** The `google-services` catalogue (D987): offered to the engine when the addon initialises. */
-var ADDON_MIGRATIONS = [{
-	meta: {
-		id: "google-services/2026-11-03-calendar-ids-to-brokers",
-		owner: "google-services",
-		level: "addon-state",
-		seq: 1,
-		dependsOn: [],
-		store: "settings",
-		scope: "cluster",
-		onFailure: "tolerate",
-		bodyKind: "procedure",
-		description: "Copy the shared calendar set to every Google broker record that has none of its own",
-		fixtureMark: "the client secret marker of a broker record the migration does not know"
-	},
-	procedure: copyCalendarIdsToBrokers
-}, {
-	meta: {
-		id: "google-services/2026-11-03-drop-shared-calendar-ids",
-		owner: "google-services",
-		level: "addon-state",
-		seq: 2,
-		dependsOn: ["google-services/2026-11-03-calendar-ids-to-brokers"],
-		store: "settings",
-		scope: "cluster",
-		onFailure: "tolerate",
-		bodyKind: "plan",
-		description: "Delete the shared calendar set once every broker shows its own",
-		fixtureMark: "the shared set parked when a broker holds a different one"
-	},
-	plan: planDropSharedCalendarIds
-}];
+var ADDON_MIGRATIONS = [
+	{
+		meta: {
+			id: "google-services/2026-11-03-calendar-ids-to-brokers",
+			owner: "google-services",
+			level: "addon-state",
+			seq: 1,
+			dependsOn: [],
+			store: "settings",
+			scope: "cluster",
+			onFailure: "tolerate",
+			bodyKind: "procedure",
+			description: "Copy the shared calendar set to every Google broker record that has none of its own",
+			fixtureMark: "the client secret marker of a broker record the migration does not know"
+		},
+		procedure: copyCalendarIdsToBrokers
+	},
+	{
+		meta: {
+			id: "google-services/2026-11-03-drop-shared-calendar-ids",
+			owner: "google-services",
+			level: "addon-state",
+			seq: 2,
+			dependsOn: ["google-services/2026-11-03-calendar-ids-to-brokers"],
+			store: "settings",
+			scope: "cluster",
+			onFailure: "tolerate",
+			bodyKind: "plan",
+			description: "Delete the shared calendar set once every broker shows its own",
+			fixtureMark: "the shared set parked when a broker holds a different one"
+		},
+		plan: planDropSharedCalendarIds
+	},
+	{
+		meta: {
+			id: "google-services/2026-11-07-calendar-ids-to-calendar-records",
+			owner: "google-services",
+			level: "addon-state",
+			seq: 3,
+			dependsOn: ["google-services/2026-11-03-drop-shared-calendar-ids"],
+			store: "settings",
+			scope: "cluster",
+			onFailure: "tolerate",
+			bodyKind: "procedure",
+			description: "Write one calendar record per calendar an account imports (linked to the account), read each back, then clear the calendar array of the account row",
+			fixtureMark: "the client secret marker of the account that keeps its calendars"
+		},
+		procedure: (ports) => moveCalendarIdsToRecords(ports, { calendarIdOf: (accountId, entry) => {
+			const parsed = parseStampedCalendarId(entry);
+			return parsed?.brokerId === accountId ? parsed.googleCalendarId : null;
+		} })
+	}
+];
 //#endregion
 //#region src/migrations/ports.ts
+function listOf(value) {
+	if (!Array.isArray(value)) return void 0;
+	return value.filter((item) => typeof item === "string");
+}
 /** The migration's ports over the `brokers` record kind and the addon's raw settings read. */
 function calendarIdsPortsOver(kind, readStored) {
 	return {
@@ -92446,18 +92771,43 @@ function calendarIdsPortsOver(kind, readStored) {
 		listBrokers: async () => {
 			return (await kind.query({ limit: 1e3 })).records.map((record) => ({
 				id: record.id,
-				calendarIds: record.data.calendarIds
+				calendarIds: listOf(record.data["calendarIds"])
 			}));
 		},
 		setBrokerCalendarIds: async (id, ids) => {
 			const row = await kind.get(id);
 			if (row === null) return false;
-			if (row.data.calendarIds !== void 0) return true;
+			if (row.data["calendarIds"] !== void 0) return true;
 			await kind.patch(id, { calendarIds: [...ids] });
 			return true;
 		}
 	};
 }
+/** The ports of the calendars move: the raw `brokers` rows and the `calendars` records. */
+function calendarRecordPortsOver(deps) {
+	return {
+		warn: deps.warn,
+		listAccounts: async () => {
+			return (await deps.brokers.query({ limit: 1e3 })).records.map((record) => ({
+				id: record.id,
+				calendarIds: record.data["calendarIds"]
+			}));
+		},
+		readCalendar: async (recordId) => {
+			const row = await deps.calendars.get(recordId);
+			return row === null ? null : row.data;
+		},
+		putCalendar: async (recordId, body) => {
+			await deps.calendars.put({
+				id: recordId,
+				data: body
+			}, { ifRev: 0 });
+		},
+		clearCalendarIds: async (accountId) => {
+			await deps.brokers.patch(accountId, { calendarIds: null });
+		}
+	};
+}
 //#endregion
 //#region src/google-broker-store.ts
 function rowToEntry(id, data) {
@@ -92496,15 +92846,14 @@ var GoogleBrokerStore = class GoogleBrokerStore {
 		const nextIds = new Set(entries.map((e) => e.id));
 		for (const row of page.records) if (!nextIds.has(row.id)) await this.kind.delete(row.id);
 		for (const entry of entries) {
-			const { id, name, clientId, clientSecret, calendarFilter, fromAddress, fromName, calendarIds } = entry;
+			const { id, name, clientId, clientSecret, calendarFilter, fromAddress, fromName } = entry;
 			const body = {
 				name,
 				clientId,
 				clientSecret,
 				calendarFilter,
 				fromAddress,
-				fromName,
-				...calendarIds !== void 0 ? { calendarIds } : {}
+				fromName
 			};
 			const parsed = googleBrokersEntryKind.schema.safeParse(body);
 			if (!parsed.success) throw new Error(`invalid Google broker '${id}': ${parsed.error.message}`);
@@ -92550,6 +92899,9 @@ var GoogleServicesAddon = class extends BaseAddon {
 	registry = new GoogleBrokerRegistry();
 	brokerStore = null;
 	instances = null;
+	calendarInstances = null;
+	/** The stamped calendar ids each account imports, from the `calendars` records. */
+	calendarSelection = /* @__PURE__ */ new Map();
 	activeBrokers = [];
 	/** CSRF state → { brokerId, issuedAt } for the in-flight OAuth consents. */
 	pendingStates = /* @__PURE__ */ new Map();
@@ -92595,15 +92947,23 @@ var GoogleServicesAddon = class extends BaseAddon {
 		}
 		const records = this.ctx.records;
 		if (records === void 0) throw new Error("google-services: ctx.records is required (hub-only addon)");
-		await records.declare({ brokers: googleBrokersEntryKind });
+		await records.declare({
+			brokers: googleBrokersEntryKind,
+			calendars: googleCalendarsEntryKind
+		});
 		this.brokerStore = GoogleBrokerStore.of(records);
 		this.instances = this.buildInstances(records);
+		this.calendarInstances = buildGoogleCalendarInstances(records, {
+			catalog: (accountId) => this.loadCalendarCatalog(accountId),
+			onChanged: () => this.refreshCalendarSelection()
+		});
 		this.activeBrokers = await this.loadPersistedBrokers();
 		if ((await this.brokerStore.listResolved()).length === 0 && this.config.brokers.length > 0) {
 			await this.brokerStore.replaceAll(this.config.brokers);
 			this.activeBrokers = await this.loadPersistedBrokers();
 		}
 		await this.migrateCalendarIds(records);
+		await this.refreshCalendarSelection();
 		this.registry.seedFrom(this.activeBrokers, oauthAccounts.accounts);
 		await this.refreshPublicOrigin();
 		const calendarProvider = createGoogleCalendarSource({
@@ -92613,7 +92973,7 @@ var GoogleServicesAddon = class extends BaseAddon {
 				connected: this.registry.isConnected(entry.id),
 				api: createGoogleCalendarApi(() => this.ensureAccessToken(entry.id))
 			})),
-			selectedCalendarIds: (brokerId) => this.calendarIdsOf(brokerId)
+			selectedCalendarIds: (brokerId) => this.calendarSelection.get(brokerId) ?? /* @__PURE__ */ new Set()
 		});
 		const smtpProvider = createGmailSmtpProvider({ accounts: () => this.registry.listEntries().map((entry) => {
 			const oauth = this.registry.getOauth(entry.id);
@@ -92662,7 +93022,7 @@ var GoogleServicesAddon = class extends BaseAddon {
 			},
 			{
 				capability: integrationInstancesCapability,
-				provider: this.requireInstances().toProvider()
+				provider: this.buildInstancesProvider()
 			},
 			{
 				capability: calendarSourceCapability,
@@ -92687,6 +93047,41 @@ var GoogleServicesAddon = class extends BaseAddon {
 		if (this.instances === null) throw new Error("google-services: instances used before initialize");
 		return this.instances;
 	}
+	/** One provider over the two record kinds: the Google accounts and the calendars they import. */
+	buildInstancesProvider() {
+		const calendars = this.calendarInstances;
+		if (calendars === null) throw new Error("google-services: instances used before initialize");
+		return composeInstanceKinds([{
+			kind: {
+				...googleAccountKind({
+					connectPath: `/addon/${ADDON_ID}${START_PATH}?brokerId={{brokerId}}`,
+					disconnectPath: `/addon/${ADDON_ID}${DISCONNECT_PATH}?brokerId={{brokerId}}`
+				}),
+				functionCap: "broker"
+			},
+			provider: this.requireInstances().toProvider()
+		}, {
+			kind: {
+				id: GOOGLE_CALENDAR_INSTANCE_KIND,
+				label: "Google calendar",
+				functionCap: "calendar-source",
+				role: "services"
+			},
+			provider: calendars.toProvider()
+		}], {
+			role: "services",
+			instanceMode: "multiple",
+			kind: "account",
+			canTest: true,
+			allowRestoreId: true
+		});
+	}
+	/** Re-read which calendars each account imports from the records. */
+	async refreshCalendarSelection() {
+		const calendars = this.calendarInstances;
+		if (calendars === null) return;
+		this.calendarSelection = selectedStampedIds(await calendars.listResolved());
+	}
 	/** The accounts as `integration-instances`, over the same `brokers` records (planning#408 P3). */
 	buildInstances(records) {
 		return buildGoogleInstances(records, {
@@ -92720,7 +93115,6 @@ var GoogleServicesAddon = class extends BaseAddon {
 				const oauth = this.registry.getOauth(id);
 				return {
 					...brokerEntryToSettings(entry),
-					_calendarCatalog: await this.loadStampedCalendarCatalog(id),
 					accountEmail: oauth?.accountEmail ?? "",
 					connected: this.registry.isConnected(id)
 				};
@@ -92989,11 +93383,25 @@ var GoogleServicesAddon = class extends BaseAddon {
 		for (const [k, v] of this.pendingStates) if (v.issuedAt < cutoff) this.pendingStates.delete(k);
 	}
 	/**
-	* The shared calendar set becomes each broker's own (D985, D987). Brokers are reloaded once the
-	* copy landed, so the registry is seeded with the sets the migration wrote.
+	* The shared calendar set becomes each broker's own (D985, D987), then each broker's set becomes
+	* `calendars` records linked to the account (D1013). Brokers are reloaded once a migration
+	* landed, so the registry is seeded with what it wrote.
 	*/
 	async migrateCalendarIds(records) {
-		if ((await this.runMigrations(defineAddonMigrations(ADDON_MIGRATIONS, calendarIdsPortsOver(records.kind(googleBrokersEntryKind), (key) => this.readStoredGlobalKey(key))))).applied.length > 0) this.activeBrokers = await this.loadPersistedBrokers();
+		const brokers = records.kind({
+			name: googleBrokersEntryKind.name,
+			declaration: googleBrokersEntryKind.declaration,
+			schema: record(string(), unknown())
+		});
+		const ports = {
+			...calendarIdsPortsOver(brokers, (key) => this.readStoredGlobalKey(key)),
+			...calendarRecordPortsOver({
+				brokers,
+				calendars: records.kind(googleCalendarsEntryKind),
+				warn: (message) => this.ctx.logger.warn(message)
+			})
+		};
+		if ((await this.runMigrations(defineAddonMigrations(ADDON_MIGRATIONS, ports))).applied.length > 0) this.activeBrokers = await this.loadPersistedBrokers();
 	}
 	async loadPersistedBrokers() {
 		const store = this.brokerStore;
@@ -93017,30 +93425,24 @@ var GoogleServicesAddon = class extends BaseAddon {
 		if (!this.oauthAccountsHandle) return;
 		await this.oauthAccountsHandle.set({ accounts: [...this.registry.listOauthAccounts()] });
 	}
-	/** Stamped catalog for Connectivity → Calendars (`optionsFrom`). */
-	async loadStampedCalendarCatalog(onlyBrokerId) {
-		const out = [];
-		for (const entry of this.registry.listEntries()) {
-			if (onlyBrokerId !== void 0 && entry.id !== onlyBrokerId) continue;
-			if (!this.registry.isConnected(entry.id)) continue;
-			try {
-				const list = await createGoogleCalendarApi(() => this.ensureAccessToken(entry.id)).listCalendars();
-				const accountLabel = this.registry.getOauth(entry.id)?.accountEmail || entry.name;
-				for (const c of list) {
-					const summary = c.summary.trim().length > 0 ? c.summary : c.id;
-					out.push({
-						value: stampCalendarId(entry.id, c.id),
-						label: `${summary} (${accountLabel})`
-					});
-				}
-			} catch (err) {
-				this.ctx.logger.warn("google calendar catalog failed", { meta: {
-					brokerId: entry.id,
-					error: err instanceof Error ? err.message : String(err)
-				} });
-			}
+	/** The calendars one signed-in account lists, by their own id (the picker of a calendar record). */
+	async loadCalendarCatalog(accountId) {
+		const entry = this.registry.getEntry(accountId);
+		if (entry === null || !this.registry.isConnected(entry.id)) return [];
+		try {
+			const api = createGoogleCalendarApi(() => this.ensureAccessToken(entry.id));
+			const accountLabel = this.registry.getOauth(entry.id)?.accountEmail || entry.name;
+			return (await api.listCalendars()).map((c) => ({
+				value: c.id,
+				label: `${c.summary.trim().length > 0 ? c.summary : c.id} (${accountLabel})`
+			})).toSorted((a, b) => a.label.localeCompare(b.label));
+		} catch (err) {
+			this.ctx.logger.warn("google calendar catalog failed", { meta: {
+				brokerId: entry.id,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+			return [];
 		}
-		return out.toSorted((a, b) => a.label.localeCompare(b.label));
 	}
 	async emitGoogleBrokerReconnectAlert(brokerId, brokerName) {
 		const emit = this.ctx.api.alerts?.emit;
@@ -93163,14 +93565,6 @@ var GoogleServicesAddon = class extends BaseAddon {
 		await this.refreshPublicOrigin();
 		return super.getGlobalSettings(overlay, cap, nodeId);
 	}
-	/**
-	* The stamped calendar ids ONE broker imports. A broker the migration has not reached yet
-	* (no `calendarIds` of its own) reads the shared setting older versions wrote, so the move
-	* never changes what is imported mid-way.
-	*/
-	calendarIdsOf(brokerId) {
-		return calendarIdsOfEntry(this.registry.getEntry(brokerId), this.config.calendarIds ?? []);
-	}
 };
 function asSettingsCap(cap) {
 	if (cap === "calendar-source" || cap === "smtp-provider") return cap;