@milaboratories/pl-middle-layer 1.68.3 → 1.69.0

package/dist/middle_layer/middle_layer.cjs

@@ -2,9 +2,12 @@ const require_registry_v2_provider = require("../block_registry/registry-v2-prov
 require("../block_registry/index.cjs");
 const require_project_model = require("../model/project_model.cjs");
 const require_project_list = require("./project_list.cjs");
+const require_template_list = require("./template_list.cjs");
+const require_template = require("../mutator/template.cjs");
 const require_sharing_model = require("../model/sharing_model.cjs");
 const require_template_resolve = require("../model/template_resolve.cjs");
 const require_template_apply = require("../model/template_apply.cjs");
+const require_template_share = require("../model/template_share.cjs");
 const require_block_pack = require("../mutator/block-pack/block_pack.cjs");
 const require_index$1 = require("../debug/index.cjs");
 const require_project = require("../mutator/project.cjs");
@@ -50,33 +53,39 @@ var MiddleLayer = class MiddleLayer {
 	driverKit;
 	signer;
 	projectListResourceId;
+	templateListResourceId;
 	sharingOutboxResourceId;
 	sharingStateResourceId;
 	openedProjectsList;
 	projectListTree;
+	templateListTree;
 	sharingOutboxTree;
 	sharingStateTree;
 	pendingSharesTree;
 	blockRegistryProvider;
 	projectList;
+	templateList;
 	outgoingShares;
 	pendingShares;
 	liveEnvelopes;
 	pl;
-	constructor(env, driverKit, signer, projectListResourceId, sharingOutboxResourceId, sharingStateResourceId, openedProjectsList, projectListTree, sharingOutboxTree, sharingStateTree, pendingSharesTree, blockRegistryProvider, projectList, outgoingShares, pendingShares, liveEnvelopes) {
+	constructor(env, driverKit, signer, projectListResourceId, templateListResourceId, sharingOutboxResourceId, sharingStateResourceId, openedProjectsList, projectListTree, templateListTree, sharingOutboxTree, sharingStateTree, pendingSharesTree, blockRegistryProvider, projectList, templateList, outgoingShares, pendingShares, liveEnvelopes) {
 		this.env = env;
 		this.driverKit = driverKit;
 		this.signer = signer;
 		this.projectListResourceId = projectListResourceId;
+		this.templateListResourceId = templateListResourceId;
 		this.sharingOutboxResourceId = sharingOutboxResourceId;
 		this.sharingStateResourceId = sharingStateResourceId;
 		this.openedProjectsList = openedProjectsList;
 		this.projectListTree = projectListTree;
+		this.templateListTree = templateListTree;
 		this.sharingOutboxTree = sharingOutboxTree;
 		this.sharingStateTree = sharingStateTree;
 		this.pendingSharesTree = pendingSharesTree;
 		this.blockRegistryProvider = blockRegistryProvider;
 		this.projectList = projectList;
+		this.templateList = templateList;
 		this.outgoingShares = outgoingShares;
 		this.pendingShares = pendingShares;
 		this.liveEnvelopes = liveEnvelopes;
@@ -263,13 +272,29 @@ var MiddleLayer = class MiddleLayer {
 	*   the whole document
 	*/
 	async applyTemplateToProject(id, document, provider, options = {}) {
-		const resolution = await require_template_resolve.resolveTemplateEntries(document, provider, { allowUnstable: options.allowUnstable ?? false });
-		if (resolution.problems.length > 0) return {
+		const preparation = await this.prepareTemplateEntries(document, provider, { allowUnstable: options.allowUnstable ?? false });
+		if (preparation.problems.length > 0) return {
 			added: [],
-			problems: resolution.problems
+			problems: preparation.problems
 		};
-		const byEntryId = new Map(document.blocks.map((entry) => [entry.id, entry]));
+		return await this.applyPreparedEntries(id, document, preparation.prepared, options.author);
+	}
+	/**
+	* Stages 1 and 2 of an apply — resolve every entry to a block pack, then prepare every
+	* block — for a document that may not have a project yet.
+	*
+	* Neither stage creates anything, which is what lets a caller run them before it decides to
+	* create a project at all: {@link createProjectFromTemplate} does exactly that, so an
+	* unapplicable template leaves no empty project behind.
+	*/
+	async prepareTemplateEntries(document, provider, options) {
 		const prepared = /* @__PURE__ */ new Map();
+		const resolution = await require_template_resolve.resolveTemplateEntries(document, provider, options);
+		if (resolution.problems.length > 0) return {
+			prepared,
+			problems: [...resolution.problems]
+		};
+		const byEntryId = new Map(document.blocks.map((entry) => [entry.id, entry]));
 		const problems = [];
 		for (const entry of resolution.resolved) try {
 			const documentEntry = byEntryId.get(entry.entryId);
@@ -305,14 +330,22 @@ var MiddleLayer = class MiddleLayer {
 				error: `This entry's block could not be installed: ${(0, _platforma_sdk_model.ensureError)(e).message}`
 			});
 		}
-		if (problems.length > 0) return {
-			added: [],
+		return {
+			prepared,
 			problems
 		};
+	}
+	/**
+	* Stage 3 of an apply — create the blocks in one transaction, all or nothing.
+	*
+	* An entry it cannot create throws, the transaction is never committed, and the project keeps
+	* none of the blocks the apply had placed.
+	*/
+	async applyPreparedEntries(id, document, prepared, author) {
 		const rid = await this.resolveProjectId(id);
 		let added = [];
 		try {
-			await require_project.withProjectAuthored(this.env.projectHelper, this.pl, rid, options.author, (mut) => {
+			await require_project.withProjectAuthored(this.env.projectHelper, this.pl, rid, author, (mut) => {
 				added = require_template_construct.applyTemplateEntries({
 					document,
 					placer: mut,
@@ -338,6 +371,131 @@ var MiddleLayer = class MiddleLayer {
 			problems: []
 		};
 	}
+	templateIdCache = new lru_cache.LRUCache({ max: 1024 });
+	/**
+	* Saves a project as a template: a snapshot of its blocks and their params, no data.
+	*
+	* The document the export produced is what gets stored; the YAML it also rendered is a
+	* file format, and a stored template is rendered to it only on download.
+	*
+	* A block that cannot be expressed as a template entry stores nothing at all, and every
+	* such block is reported — fixing an unexportable project takes one pass, not one per block.
+	*
+	* @param projectId project to snapshot
+	* @param label label for the template; defaults to the project's own label
+	*/
+	async saveProjectAsTemplate(projectId, label) {
+		const outcome = await this.exportProjectAsTemplate(projectId);
+		if (!outcome.ok) return {
+			ok: false,
+			problems: outcome.problems
+		};
+		const rid = await this.resolveProjectId(projectId);
+		let tpl;
+		await this.pl.withWriteTx("MLSaveProjectAsTemplate", async (tx) => {
+			const meta = await tx.getKValueJson(rid, require_project_model.ProjectMetaKey);
+			tpl = require_template.createTemplate(tx, this.templateListResourceId, label ?? meta.label, {
+				schemaVersion: 1,
+				document: outcome.document,
+				sourceProjectLabel: meta.label
+			});
+			await tx.commit();
+		});
+		await this.templateListTree.refreshState();
+		const signedRid = await tpl.globalId;
+		const templateId = (0, _milaboratories_pl_client.resourceIdToString)(signedRid);
+		this.templateIdCache.set(templateId, signedRid);
+		return {
+			ok: true,
+			templateId
+		};
+	}
+	/** Changes a template's label. The stored document is immutable and stays untouched —
+	*  improving a template means saving a new one. */
+	async renameTemplate(id, label) {
+		const rid = await this.resolveTemplateId(id);
+		await this.pl.withWriteTx("MLRenameTemplate", async (tx) => {
+			require_template.renameTemplate(tx, rid, label);
+			await tx.commit();
+		});
+		await this.templateListTree.refreshState();
+	}
+	/** Permanently deletes a template from the template list. */
+	async deleteTemplate(id) {
+		await this.pl.withWriteTx("MLRemoveTemplate", async (tx) => {
+			await require_template.deleteTemplate(tx, this.templateListResourceId, id);
+			await tx.commit();
+		});
+		this.templateIdCache.delete(id);
+		await this.templateListTree.refreshState();
+	}
+	/** Reads a stored template: its document plus what was true when it was taken. */
+	async getTemplateData(id) {
+		const rid = await this.resolveTemplateId(id);
+		return await this.pl.withReadTx("MLGetTemplate", async (tx) => {
+			const rd = await tx.getResourceData(rid, false);
+			if (rd.data === void 0) throw new Error(`Template ${id} carries no document.`);
+			return require_template_list.decodeStoredTemplateData(rd.data);
+		});
+	}
+	/**
+	* Where each entry of a stored template would get its block from, and which entries have
+	* nowhere to get one — resolution creates nothing, so this is the preview a UI shows before
+	* offering Apply. {@link createProjectFromTemplate} runs the same stage itself.
+	*/
+	async resolveTemplate(id, provider, options = {}) {
+		return await require_template_resolve.resolveTemplateEntries((await this.getTemplateData(id)).document, provider, { allowUnstable: options.allowUnstable ?? false });
+	}
+	/**
+	* Creates one project holding every block the stored template lists, in the template's order.
+	*
+	* Resolution and preparation run before the project exists, so a template with an entry
+	* nothing can supply a block for leaves no empty project in the list. The one write that
+	* follows is all or nothing, and an entry it rejects takes the project with it.
+	*
+	* @param id template to apply
+	* @param label label for the new project
+	* @param provider where each entry's block comes from
+	* @param options `allowUnstable` widens resolution to pre-release implementations
+	*/
+	async createProjectFromTemplate(id, label, provider, options = {}) {
+		const stored = await this.getTemplateData(id);
+		const preparation = await this.prepareTemplateEntries(stored.document, provider, { allowUnstable: options.allowUnstable ?? false });
+		if (preparation.problems.length > 0) return {
+			ok: false,
+			problems: preparation.problems
+		};
+		const projectId = await this.createProject({ label });
+		const report = await this.applyPreparedEntries(projectId, stored.document, preparation.prepared, options.author);
+		if (report.problems.length > 0) {
+			await this.deleteProject(projectId);
+			return {
+				ok: false,
+				problems: report.problems
+			};
+		}
+		return {
+			ok: true,
+			projectId,
+			added: report.added
+		};
+	}
+	/** Resolves a TemplateId to a signed SignedResourceId.
+	* Uses LRU cache with TX-scan fallback. */
+	async resolveTemplateId(templateId) {
+		const cached = this.templateIdCache.get(templateId);
+		if (cached !== void 0) return cached;
+		const rid = await this.pl.withReadTx("ResolveTemplateId", async (tx) => {
+			const data = await tx.getResourceData(this.templateListResourceId, true);
+			for (const f of data.fields) {
+				if ((0, _milaboratories_pl_client.isNullSignedResourceId)(f.value)) continue;
+				if ((0, _milaboratories_pl_client.resourceIdToString)(f.value) === templateId) return f.value;
+			}
+			throw new Error(`Template ${templateId} not found in template list.`);
+		});
+		this.templateIdCache.set(templateId, rid);
+		return rid;
+	}
 	/** Permanently deletes project from the project list, this will result in
 	* destruction of all attached objects, like files, analysis results etc. */
 	async deleteProject(id) {
@@ -467,14 +625,98 @@ var MiddleLayer = class MiddleLayer {
 				title: options.title,
 				expiresAt
 			});
-			const envelopeGid = await envelope.globalId;
-			if (everyone) tx.grantAccess(envelopeGid, "", { writable: true }, _milaboratories_pl_client.GrantType.ANY_AUTHORISED);
-			else for (const recipient of options.recipients) tx.grantAccess(envelopeGid, recipient, { writable: true });
+			await this.grantShareEnvelope(tx, envelope, everyone, everyone ? [] : options.recipients, { writable: true });
 			await tx.commit();
 		});
 		await this.sharingOutboxTree.refreshState();
 	}
 	/**
+	* Grants one freshly built envelope inside the transaction that created it: a single make-public
+	* grant for an everyone-share (empty/ignored target, ANY_AUTHORISED — the backend rewrites the
+	* target to the everyone-user, gated by role + permission ceiling), or one grant per named
+	* recipient.
+	*
+	* `writable` is not a preference. A project pack needs a writable grant because accepting copies
+	* the snapshots out of the envelope, and the cross-color attach rule permits that only to a
+	* writable grant holder. A template share copies nothing — the document sits in the envelope's
+	* own immutable data — so it is granted read-only, and must be: a writable everyone-grant would
+	* hand every user on the server write access to the envelope.
+	*/
+	async grantShareEnvelope(tx, envelope, everyone, recipients, permissions) {
+		const gid = await envelope.globalId;
+		if (everyone) tx.grantAccess(gid, "", permissions, _milaboratories_pl_client.GrantType.ANY_AUTHORISED);
+		else for (const r of recipients) tx.grantAccess(gid, r, permissions);
+	}
+	/**
+	* Shares one stored template. The envelope carries the document itself, so there is no project
+	* snapshot and no resource for the recipient to copy out — which is why the grant is read-only.
+	* The cost of that is the donor's receipt: nobody can write an acceptance onto a read-only
+	* envelope, so a template share never reports who accepted it.
+	*
+	* A template holding a block installed from a folder on this machine is refused rather than sent,
+	* with every offending entry named. {@link checkTemplateShareable} answers the same question
+	* without attempting the share, so a UI can state it on the template itself.
+	*
+	* @param id template to share
+	* @param options recipients XOR everyone, plus the title recipients see
+	*/
+	async shareTemplate(id, options) {
+		const loaded = await this.loadShareableTemplate(id);
+		if (!loaded.ok) return {
+			ok: false,
+			problems: loaded.problems
+		};
+		const everyone = "everyone" in options;
+		const sender = this.currentUserLogin ?? "";
+		const expiresAt = everyone ? null : Date.now() + this.env.ops.envelopeTtlMs;
+		let shareId;
+		await this.pl.withWriteTx("MLShareTemplate", async (tx) => {
+			const { envelope, data } = require_sharing.buildTemplateShareEnvelope(tx, this.sharingOutboxResourceId, loaded.template, {
+				sender,
+				title: options.title,
+				expiresAt
+			});
+			shareId = data.shareId;
+			await this.grantShareEnvelope(tx, envelope, everyone, everyone ? [] : options.recipients, { writable: false });
+			await tx.commit();
+		});
+		await this.sharingOutboxTree.refreshState();
+		return {
+			ok: true,
+			shareId
+		};
+	}
+	/**
+	* Every entry of a stored template that stands in the way of sharing it, empty for a template
+	* that can be shared. Reads the template and nothing else, so a UI can state the refusal on the
+	* template itself instead of only when the user tries to share it.
+	*/
+	async checkTemplateShareable(id) {
+		return require_template_share.unshareableTemplateEntries((await this.getTemplateData(id)).document);
+	}
+	/** The document and the label of a template that may be shared, or every entry that stops it.
+	*  The label is what the recipient's own list will show, so it travels with the document. */
+	async loadShareableTemplate(id) {
+		const rid = await this.resolveTemplateId(id);
+		const template = await this.pl.withReadTx("MLReadTemplateForShare", async (tx) => {
+			const rd = await tx.getResourceData(rid, false);
+			if (rd.data === void 0) throw new Error(`Template ${id} carries no document.`);
+			return {
+				document: require_template_list.decodeStoredTemplateData(rd.data).document,
+				label: await tx.getKValueJson(rid, require_template_list.TemplateLabelKey)
+			};
+		});
+		const problems = require_template_share.unshareableTemplateEntries(template.document);
+		if (problems.length > 0) return {
+			ok: false,
+			problems
+		};
+		return {
+			ok: true,
+			template
+		};
+	}
+	/**
 	* Changes a share in place (same {@link ShareId}), in one write transaction: re-snapshots live
 	* source projects and carries deleted ones' snapshots forward; applies edited recipients/title;
 	* transfers already-decided recipients' accept/reject records (they keep their copy and aren't
@@ -489,14 +731,37 @@ var MiddleLayer = class MiddleLayer {
 	* existing snapshot (and its timestamp), `remove` drops the project from the pack. A project not
 	* in the map defaults to `keep`. Omit the whole map for the legacy auto behavior (live sources
 	* updated, gone ones kept) — the everyone-refresh path relies on that.
+	*
+	* `opts.templateId` is required for, and only used by, a share that carries a template: a stored
+	* template is immutable, so an improved one is a different template and the share cannot re-read
+	* the one it started from — the caller names the new target. Every other option means the same
+	* thing for both kinds of share. Sharing the named template must be permitted (see
+	* {@link checkTemplateShareable}) or this throws.
 	*/
 	async changeShare(shareId, opts = {}) {
+		const target = opts.templateId === void 0 ? void 0 : await this.loadShareableTemplate(opts.templateId);
+		if (target !== void 0 && !target.ok) throw new Error(`changeShare: template ${opts.templateId} cannot be shared: ${describeShareProblems(target.problems)}`);
 		await this.pl.withWriteTx("MLChangeShare", async (tx) => {
 			const old = await this.resolveOutboxEnvelope(tx, shareId);
 			if (old === void 0) throw new Error(`changeShare: no live share with id ${shareId} in the outbox.`);
 			const self = this.currentUserLogin ?? "";
 			const grants = await tx.listGrants(old.rid);
 			const everyone = grants.some((g) => (0, _milaboratories_pl_client.isEveryoneUserLogin)(g.user)) || opts.everyone === true;
+			const priorRecipients = grants.filter((g) => !(0, _milaboratories_pl_client.isEveryoneUserLogin)(g.user) && g.user !== self).map((g) => g.user);
+			if (old.data.payload.kind === "template") {
+				if (target === void 0) throw new Error(`changeShare: share ${shareId} carries a template, so it needs an explicit target template — a stored template never changes, so an improved one is a different template.`);
+				const recipients = everyone ? [] : opts.recipients ?? priorRecipients;
+				tx.removeField((0, _milaboratories_pl_client.field)(this.sharingOutboxResourceId, old.fieldName));
+				const { envelope } = require_sharing.buildTemplateShareEnvelope(tx, this.sharingOutboxResourceId, target.template, {
+					sender: self,
+					title: opts.title === void 0 ? old.data.title : opts.title.trim(),
+					expiresAt: everyone ? null : Date.now() + this.env.ops.envelopeTtlMs,
+					shareId
+				});
+				await this.grantShareEnvelope(tx, envelope, everyone, recipients, { writable: false });
+				await tx.commit();
+				return;
+			}
 			const oldRd = await tx.getResourceData(old.rid, true);
 			const snapshotByUuid = /* @__PURE__ */ new Map();
 			const acceptances = [];
@@ -513,7 +778,6 @@ var MiddleLayer = class MiddleLayer {
 				}
 			}
 			const decidedLogins = acceptances.map((a) => a.login);
-			const priorRecipients = grants.filter((g) => !(0, _milaboratories_pl_client.isEveryoneUserLogin)(g.user) && g.user !== self).map((g) => g.user);
 			const recipients = everyone ? [] : Array.from(/* @__PURE__ */ new Set([...opts.recipients ?? priorRecipients, ...decidedLogins]));
 			const liveProjects = /* @__PURE__ */ new Map();
 			const projList = await tx.getResourceData(this.projectListResourceId, true);
@@ -523,8 +787,9 @@ var MiddleLayer = class MiddleLayer {
 			}
 			const actions = opts.projectActions;
 			const sources = [];
-			for (const uuid of Object.keys(old.data.projects)) {
-				const { label, source, updatedAt } = old.data.projects[uuid];
+			const oldProjects = require_sharing_model.envelopeProjectMap(old.data);
+			for (const uuid of Object.keys(oldProjects)) {
+				const { label, source, updatedAt } = oldProjects[uuid];
 				const liveRid = liveProjects.get(source);
 				const action = actions ? actions[source] ?? "keep" : liveRid !== void 0 ? "update" : "keep";
 				if (action === "remove") continue;
@@ -558,9 +823,7 @@ var MiddleLayer = class MiddleLayer {
 				if (!everyone && !recipients.includes(login)) continue;
 				require_sharing.writeEnvelopeAcceptance(tx, envelope, login, acc.action, acc.timestamp);
 			}
-			const gid = await envelope.globalId;
-			if (everyone) tx.grantAccess(gid, "", { writable: true }, _milaboratories_pl_client.GrantType.ANY_AUTHORISED);
-			else for (const r of recipients) tx.grantAccess(gid, r, { writable: true });
+			await this.grantShareEnvelope(tx, envelope, everyone, recipients, { writable: true });
 			await tx.commit();
 		});
 		await this.sharingOutboxTree.refreshState();
@@ -581,7 +844,8 @@ var MiddleLayer = class MiddleLayer {
 				const rd = await tx.getResourceData(f.value, false);
 				if (rd.data === void 0) continue;
 				const data = require_sharing_model.decodeEnvelopeData(rd.data);
-				if (Object.values(data.projects).some((p) => wanted.has(p.source))) out.push({
+				if (data === void 0) continue;
+				if (Object.values(require_sharing_model.envelopeProjectMap(data)).some((p) => wanted.has(p.source))) out.push({
 					fieldName: f.name,
 					rid: f.value,
 					shareId: data.shareId
@@ -627,6 +891,7 @@ var MiddleLayer = class MiddleLayer {
 			const rd = await tx.getResourceData(f.value, false);
 			if (rd.data === void 0) continue;
 			const data = require_sharing_model.decodeEnvelopeData(rd.data);
+			if (data === void 0) continue;
 			if (data.shareId === shareId) return {
 				fieldName: f.name,
 				rid: f.value,
@@ -652,18 +917,23 @@ var MiddleLayer = class MiddleLayer {
 		return map;
 	}
 	/**
-	* Accepts one or more pending shares: duplicates each share's projects into this user's
-	* project list, records the decision per share, and (read-write share) writes the donor-visible
-	* acceptance onto the envelope. Per-share failures (e.g. an expiry race) are collected, not
-	* short-circuited — the rest still get accepted. Accept-all = pass every current pending shareId.
+	* Accepts one or more pending shares. What accepting does depends on what the share carries: a
+	* pack of projects is duplicated into this user's project list, while a template is added to this
+	* user's own template list and builds nothing — the recipient decides later whether to apply it.
+	* Either way the decision is recorded per share, and a read-write share also gets the
+	* donor-visible acceptance written onto its envelope. Per-share failures (e.g. an expiry race)
+	* are collected, not short-circuited — the rest still get accepted. Accept-all = pass every
+	* current pending shareId.
 	*
 	* `rename` resolves label collisions (same callback contract as {@link duplicateProject}), but
-	* the source lives in the envelope tree, so accept calls the low-level mutator directly.
+	* the source lives in the envelope tree, so accept calls the low-level mutator directly. It does
+	* not apply to a template share, whose label is not required to be unique.
 	*/
 	async acceptShare(shareIds, rename) {
 		const live = await this.resolveLiveEnvelopes();
 		const login = this.currentUserLogin;
 		const accepted = [];
+		const acceptedTemplates = [];
 		const failed = [];
 		for (const shareId of shareIds) {
 			const envelope = live.get(shareId);
@@ -676,6 +946,28 @@ var MiddleLayer = class MiddleLayer {
 			}
 			try {
 				const now = Date.now();
+				const payload = envelope.data.payload;
+				if (payload.kind === "template") {
+					const rid = await this.pl.withWriteTx("MLAcceptTemplateShare", async (tx) => {
+						const tpl = require_template.createTemplate(tx, this.templateListResourceId, payload.label, {
+							schemaVersion: 1,
+							document: payload.document,
+							sender: payload.from
+						});
+						require_sharing.writeSharingDecision(tx, this.sharingStateResourceId, shareId, {
+							decision: "accepted",
+							timestamp: now,
+							envelopeSharedAt: envelope.data.sharedAt,
+							acceptedProjects: []
+						});
+						await tx.commit();
+						return await tpl.globalId;
+					});
+					const templateId = (0, _milaboratories_pl_client.resourceIdToString)(rid);
+					this.templateIdCache.set(templateId, rid);
+					acceptedTemplates.push(templateId);
+					continue;
+				}
 				const createdRids = await this.pl.withWriteTx("MLAcceptShare", async (tx) => {
 					const created = await require_sharing.copyEnvelopeProjectsIntoList(tx, envelope.rid, this.projectListResourceId, rename);
 					require_sharing.writeSharingDecision(tx, this.sharingStateResourceId, shareId, {
@@ -700,9 +992,14 @@ var MiddleLayer = class MiddleLayer {
 				});
 			}
 		}
-		await Promise.all([this.projectListTree.refreshState(), this.sharingStateTree.refreshState()]);
+		await Promise.all([
+			this.projectListTree.refreshState(),
+			this.templateListTree.refreshState(),
+			this.sharingStateTree.refreshState()
+		]);
 		return {
 			accepted,
+			acceptedTemplates,
 			failed
 		};
 	}
@@ -746,6 +1043,7 @@ var MiddleLayer = class MiddleLayer {
 					const rd = await tx.getResourceData(f.value, false);
 					if (rd.data === void 0) continue;
 					const envData = require_sharing_model.decodeEnvelopeData(rd.data);
+					if (envData === void 0) continue;
 					if (envData.expiresAt === null) continue;
 					if (envData.expiresAt <= now) toDelete.push({ fieldName: f.name });
 				}
@@ -830,6 +1128,7 @@ var MiddleLayer = class MiddleLayer {
 		await Promise.all([...this.openedProjects.values()].map((prj) => prj.destroy()));
 		await Promise.all([
 			this.projectListTree.terminate(),
+			this.templateListTree.terminate(),
 			this.sharingOutboxTree.terminate(),
 			this.sharingStateTree.terminate(),
 			this.pendingSharesTree.terminate()
@@ -861,7 +1160,7 @@ var MiddleLayer = class MiddleLayer {
 		ops.defaultTreeOptions.logStat = require_index$1.getDebugFlags().logTreeStats;
 		ops.debugOps.dumpInitialTreeState = require_index$1.getDebugFlags().dumpInitialTreeState;
 		if (ops.defaultTreeOptions.traversalMode === void 0 && require_index$1.getDebugFlags().treeTraversalMode !== void 0) ops.defaultTreeOptions.traversalMode = require_index$1.getDebugFlags().treeTraversalMode;
-		const { projects, sharingOutbox, sharingState } = await pl.withWriteTx("MLInitialization", async (tx) => {
+		const { projects, templates, sharingOutbox, sharingState } = await pl.withWriteTx("MLInitialization", async (tx) => {
 			const lazyInit = async (fieldName, type) => {
 				const f = (0, _milaboratories_pl_client.field)(tx.clientRoot, fieldName);
 				tx.createField(f, "Dynamic");
@@ -875,11 +1174,13 @@ var MiddleLayer = class MiddleLayer {
 				return { existing: fData.value };
 			};
 			const projectsR = await lazyInit(require_project_list.ProjectsField, require_project_list.ProjectsResourceType);
+			const templatesR = await lazyInit(require_template_list.TemplatesField, require_template_list.TemplatesResourceType);
 			const outboxR = await lazyInit(require_sharing_model.SharingOutboxField, require_sharing_model.SharingOutboxResourceType);
 			const stateR = await lazyInit(require_sharing_model.SharingStateField, require_sharing_model.SharingStateResourceType);
 			await tx.commit();
 			return {
 				projects: projectsR.existing ?? await projectsR.ref.globalId,
+				templates: templatesR.existing ?? await templatesR.ref.globalId,
 				sharingState: stateR.existing ?? await stateR.ref.globalId,
 				sharingOutbox: outboxR.existing ?? await outboxR.ref.globalId
 			};
@@ -934,14 +1235,20 @@ var MiddleLayer = class MiddleLayer {
 		};
 		const openedProjects = new _milaboratories_computable.WatchableValue([]);
 		const projectListTC = await require_project_list.createProjectList(pl, projects, openedProjects, env);
+		const templateListTC = await require_template_list.createTemplateList(pl, templates, env);
 		const outgoingTC = await require_sharing_list.createOutgoingShares(pl, sharingOutbox, env);
 		const sharingStateTree = await require_sharing_list.createSharingStateTree(pl, sharingState, env);
 		const pendingSharesTree = await require_sharing_list.createPendingSharesTree(pl, env);
 		const pendingShares = require_sharing_list.createPendingSharesComputable(pendingSharesTree, sharingStateTree, pl.userResources.authUser);
 		const liveEnvelopes = require_sharing_list.createLiveEnvelopesComputable(pendingSharesTree);
-		return new MiddleLayer(env, driverKit, driverKit.signer, projects, sharingOutbox, sharingState, openedProjects, projectListTC.tree, outgoingTC.tree, sharingStateTree, pendingSharesTree, v2RegistryProvider, projectListTC.computable, outgoingTC.computable, pendingShares, liveEnvelopes);
+		return new MiddleLayer(env, driverKit, driverKit.signer, projects, templates, sharingOutbox, sharingState, openedProjects, projectListTC.tree, templateListTC.tree, outgoingTC.tree, sharingStateTree, pendingSharesTree, v2RegistryProvider, projectListTC.computable, templateListTC.computable, outgoingTC.computable, pendingShares, liveEnvelopes);
 	}
 };
+/** Refusal reasons as one line, each naming the entry it belongs to, so a throw that escapes to a
+*  log still says which block stands in the way. */
+function describeShareProblems(problems) {
+	return problems.map((p) => `${p.entryId}: ${p.error}`).join("; ");
+}
 //#endregion
 exports.MiddleLayer = MiddleLayer;