@milaboratories/pl-middle-layer 1.69.2 → 1.71.0

package/src/middle_layer/middle_layer.ts

@@ -75,8 +75,6 @@ import {
   type ShareProjectsOptions,
   type ShareTemplateOptions,
 } from "../model/sharing_model";
-import type { TemplateShareProblem } from "../model/template_share";
-import { unshareableTemplateEntries } from "../model/template_share";
 import {
   buildShareEnvelope,
   buildTemplateShareEnvelope,
@@ -1002,9 +1000,10 @@ export class MiddleLayer {
    * 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.
+   * Nothing about the document is checked: a stored template is shareable by virtue of existing.
+   * An entry the recipient cannot resolve — a block installed from a folder on the sender's
+   * machine, say — is theirs to see when they preview or apply it, where every unresolvable entry
+   * is named anyway.
    *
    * @param id template to share
    * @param options recipients XOR everyone, plus the title recipients see
@@ -1013,8 +1012,7 @@ export class MiddleLayer {
     id: TemplateId,
     options: ShareTemplateOptions,
   ): Promise<ShareTemplateOutcome> {
-    const loaded = await this.loadShareableTemplate(id);
-    if (!loaded.ok) return { ok: false, problems: loaded.problems };
+    const template = await this.loadTemplateForShare(id);
 
     const everyone = "everyone" in options;
     const sender = this.currentUserLogin ?? "";
@@ -1026,7 +1024,7 @@ export class MiddleLayer {
       const { envelope, data } = buildTemplateShareEnvelope(
         tx,
         this.sharingOutboxResourceId,
-        loaded.template,
+        template,
         { sender, title: options.title, expiresAt },
       );
       shareId = data.shareId;
@@ -1037,29 +1035,16 @@ export class MiddleLayer {
     });
 
     await this.sharingOutboxTree.refreshState();
-    return { ok: true, shareId: shareId! };
+    return { shareId: 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.
-   */
-  public async checkTemplateShareable(id: TemplateId): Promise<readonly TemplateShareProblem[]> {
-    const stored = await this.getTemplateData(id);
-    return unshareableTemplateEntries(stored.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. */
-  private async loadShareableTemplate(
+  /** The document and the label of a template about to be shared. The label is what the
+   *  recipient's own list will show, so it travels with the document. */
+  private async loadTemplateForShare(
     id: TemplateId,
-  ): Promise<
-    | { ok: true; template: { document: ProjectTemplateV1; label: string } }
-    | { ok: false; problems: readonly TemplateShareProblem[] }
-  > {
+  ): Promise<{ document: ProjectTemplateV1; label: string }> {
     const rid = await this.resolveTemplateId(id);
-    const template = await this.pl.withReadTx("MLReadTemplateForShare", async (tx) => {
+    return await this.pl.withReadTx("MLReadTemplateForShare", async (tx) => {
       const rd = await tx.getResourceData(rid, false);
       if (rd.data === undefined) throw new Error(`Template ${id} carries no document.`);
       return {
@@ -1067,10 +1052,6 @@ export class MiddleLayer {
         label: await tx.getKValueJson<string>(rid, TemplateLabelKey),
       };
     });
-
-    const problems = unshareableTemplateEntries(template.document);
-    if (problems.length > 0) return { ok: false, problems };
-    return { ok: true, template };
   }
 
   /**
@@ -1092,8 +1073,7 @@ export class MiddleLayer {
    * `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.
+   * thing for both kinds of share.
    */
   public async changeShare(
     shareId: ShareId,
@@ -1105,14 +1085,9 @@ export class MiddleLayer {
       templateId?: TemplateId;
     } = {},
   ): Promise<void> {
-    // Read outside the write tx: it is two round-trips of its own, and the refusal it can produce
-    // must be raised before anything is torn down.
+    // Read outside the write tx: it is two round-trips of its own.
     const target =
-      opts.templateId === undefined ? undefined : await this.loadShareableTemplate(opts.templateId);
-    if (target !== undefined && !target.ok)
-      throw new Error(
-        `changeShare: template ${opts.templateId} cannot be shared: ${describeShareProblems(target.problems)}`,
-      );
+      opts.templateId === undefined ? undefined : await this.loadTemplateForShare(opts.templateId);
 
     await this.pl.withWriteTx("MLChangeShare", async (tx) => {
       const old = await this.resolveOutboxEnvelope(tx, shareId);
@@ -1137,17 +1112,12 @@ export class MiddleLayer {
 
         // Same shareId, same outbox field name — detach the old field before rebuilding, or they collide.
         tx.removeField(field(this.sharingOutboxResourceId, old.fieldName));
-        const { envelope } = buildTemplateShareEnvelope(
-          tx,
-          this.sharingOutboxResourceId,
-          target.template,
-          {
-            sender: self,
-            title: opts.title === undefined ? old.data.title : opts.title.trim(),
-            expiresAt: everyone ? null : Date.now() + this.env.ops.envelopeTtlMs,
-            shareId, // SAME shareId — the essence of change
-          },
-        );
+        const { envelope } = buildTemplateShareEnvelope(tx, this.sharingOutboxResourceId, target, {
+          sender: self,
+          title: opts.title === undefined ? old.data.title : opts.title.trim(),
+          expiresAt: everyone ? null : Date.now() + this.env.ops.envelopeTtlMs,
+          shareId, // SAME shareId — the essence of change
+        });
 
         // Nothing to transfer: a read-only grant cannot write an acceptance, so a template share
         // never accumulated one.
@@ -1828,9 +1798,3 @@ export class MiddleLayer {
 //
 // Internals
 //
-
-/** 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: readonly TemplateShareProblem[]): string {
-  return problems.map((p) => `${p.entryId}: ${p.error}`).join("; ");
-}

package/src/middle_layer/template_list.ts

@@ -20,7 +20,6 @@ import type { MiddleLayerEnvironment } from "./middle_layer";
 import { notEmpty } from "@milaboratories/ts-helpers";
 import type { Branded, ProjectTemplateV1 } from "@milaboratories/pl-model-common";
 import type { TemplateExportProblem } from "../model/template_export";
-import type { TemplateShareProblem } from "../model/template_share";
 import type { ShareId } from "../model/sharing_model";
 import type { AppliedEntry, TemplateApplyProblem } from "../model/template_apply";
 import type { ProjectId } from "../model/project_model";
@@ -80,10 +79,8 @@ export type SaveProjectAsTemplateOutcome =
   | { readonly ok: true; readonly templateId: TemplateId }
   | { readonly ok: false; readonly problems: readonly TemplateExportProblem[] };
 
-/** What sharing a stored template yields: the share's logical id, or every entry in the way. */
-export type ShareTemplateOutcome =
-  | { readonly ok: true; readonly shareId: ShareId }
-  | { readonly ok: false; readonly problems: readonly TemplateShareProblem[] };
+/** What sharing a stored template yields: the share's logical id. */
+export type ShareTemplateOutcome = { readonly shareId: ShareId };
 
 /**
  * What applying a stored template yields.

package/src/middle_layer/templates.test.ts

@@ -91,26 +91,19 @@ test("an entry nothing can resolve creates no project, and every entry is report
   });
 });
 
-test("a template holding a block from a folder on this machine is refused rather than shared", async () => {
+test("a template holding a block from a folder on this machine is shared like any other", async () => {
   await withMl(async (ml) => {
-    const stored = await storeTemplate(ml, "Built here", {
-      schemaVersion: 1,
-      document: documentOf(entry("a"), entry("b", LOCAL_FOLDER)),
-    });
+    const document = documentOf(entry("a"), entry("b", LOCAL_FOLDER));
+    const stored = await storeTemplate(ml, "Built here", { schemaVersion: 1, document });
 
-    // Asked of a template that is merely being displayed, so the refusal can be stated on the
-    // template itself instead of only once the user has tried to send it.
-    expect((await ml.checkTemplateShareable(stored.id)).map((p) => p.entryId)).toStrictEqual(["b"]);
-
-    const outcome = await ml.shareTemplate(stored.id, {
-      recipients: ["colleague"],
-      title: "Built here",
-    });
+    // A stored template is shareable by existing. Whether the recipient can resolve every entry
+    // is their question, answered where they preview or apply it — not a gate on sending.
+    // With everyone, like the other share tests here: a named recipient must already exist on
+    // the backend, and the test server has no second user.
+    const shared = await ml.shareTemplate(stored.id, { everyone: true, title: "Built here" });
 
-    if (outcome.ok) throw new Error("a template with a file: entry must not be shareable");
-    expect(outcome.problems.map((p) => p.entryId)).toStrictEqual(["b"]);
-    // Refused before anything was written: no envelope, so nothing to revoke.
-    expect((await ml.outgoingShares.getValue()) ?? []).toStrictEqual([]);
+    const outgoing = await ml.outgoingShares.awaitStableValue();
+    expect((outgoing ?? []).map((s) => s.shareId)).toStrictEqual([shared.shareId]);
   });
 });
 
@@ -142,7 +135,6 @@ test("an accepted template share lands on the acceptor's shelf and builds nothin
     });
 
     const shared = await ml.shareTemplate(stored.id, { everyone: true, title: "A pipeline" });
-    if (!shared.ok) throw new Error(`share refused: ${JSON.stringify(shared.problems)}`);
 
     const outcome = await ml.acceptShare([shared.shareId]);
 
@@ -175,7 +167,6 @@ test("a changed template share keeps its id, and whoever already responded is no
     });
 
     const shared = await ml.shareTemplate(first.id, { everyone: true, title: "First" });
-    if (!shared.ok) throw new Error(`share refused: ${JSON.stringify(shared.problems)}`);
 
     // Someone responds to the share, which is what the replace below must not undo.
     const accept = await ml.acceptShare([shared.shareId]);
@@ -186,7 +177,7 @@ test("a changed template share keeps its id, and whoever already responded is no
     await ml.changeShare(shared.shareId, { templateId: second.id, title: "Second" });
 
     const outgoing = (await ml.outgoingShares.getValue()) ?? [];
-    expect(outgoing.map((s) => s.shareId)).toStrictEqual([shared.shareId]);
+    expect((outgoing ?? []).map((s) => s.shareId)).toStrictEqual([shared.shareId]);
     expect(outgoing[0]).toMatchObject({
       payloadKind: "template",
       title: "Second",

package/src/model/index.ts

@@ -48,4 +48,3 @@ export type { TemplateExportProblem } from "./template_export";
 
 // The template share path. Whether a template may be shared at all is a question a UI asks about
 // a template it is merely displaying, so the check and its problem type are public.
-export { unshareableTemplateEntries, type TemplateShareProblem } from "./template_share";

package/src/model/template_export.test.ts

@@ -24,6 +24,35 @@ function providerFrom(params: Record<string, TemplateParamsResult>) {
 
 const ok = (value: unknown): TemplateParamsResult => ({ value });
 
+describe("labels", () => {
+  test("an entry and a problem both carry the block's label, not its id", () => {
+    // `simpleStructure` labels every block after its id, which cannot tell a label read from
+    // the structure apart from an id copied into the field. Distinct labels here can.
+    const structure: ProjectStructure = {
+      groups: [
+        {
+          id: "g1",
+          label: "G1",
+          blocks: [
+            { id: "b1", label: "MiXCR Clonotyping", renderingMode: "Heavy" },
+            { id: "b2", label: "Clonotype Browser", renderingMode: "Heavy" },
+          ],
+        },
+      ],
+    };
+    const walk = walkProjectForTemplateExport(structure, providerFrom({ b1: ok({}) }));
+
+    expect(walk.entries).toEqual([{ blockId: "b1", blockLabel: "MiXCR Clonotyping", params: {} }]);
+    expect(walk.problems).toEqual([
+      {
+        blockId: "b2",
+        blockLabel: "Clonotype Browser",
+        error: "Block state is unavailable, so its template params could not be derived",
+      },
+    ]);
+  });
+});
+
 describe("order", () => {
   test("entries come out in structure order — no sort, none needed", () => {
     // The structure IS the topological order: a block can only legally reference
@@ -101,7 +130,7 @@ describe("collecting each block's descriptor output", () => {
       providerFrom({ mixcr: ok(params) }),
     );
 
-    expect(walk.entries).toEqual([{ blockId: "mixcr", params }]);
+    expect(walk.entries).toEqual([{ blockId: "mixcr", blockLabel: "mixcr", params }]);
   });
 
   test("a block with nothing to project yields empty params", () => {
@@ -112,7 +141,9 @@ describe("collecting each block's descriptor output", () => {
       providerFrom({ "pool-explorer": ok({}) }),
     );
 
-    expect(walk.entries).toEqual([{ blockId: "pool-explorer", params: {} }]);
+    expect(walk.entries).toEqual([
+      { blockId: "pool-explorer", blockLabel: "pool-explorer", params: {} },
+    ]);
     expect(walk.problems).toEqual([]);
   });
 });
@@ -145,7 +176,7 @@ describe("what the walk does with params", () => {
       providerFrom({ block1: ok({}) }),
     );
 
-    expect(walk.entries).toEqual([{ blockId: "block1", params: {} }]);
+    expect(walk.entries).toEqual([{ blockId: "block1", blockLabel: "block1", params: {} }]);
   });
 
   test("a wrapper's contents are never inspected, whatever they are", () => {
@@ -210,7 +241,7 @@ describe("problems", () => {
     // Every offending block is reported at once rather than aborting on the
     // first, so the user fixes them in one pass.
     expect(walk.problems).toEqual([
-      { blockId: "b", error: "templateParams() threw: not exportable yet" },
+      { blockId: "b", blockLabel: "b", error: "templateParams() threw: not exportable yet" },
     ]);
     expect(walk.entries.map((e) => e.blockId)).toEqual(["a", "c"]);
   });
@@ -228,6 +259,7 @@ describe("problems", () => {
     expect(walk.problems).toEqual([
       {
         blockId: "ghost",
+        blockLabel: "ghost",
         error: "Block state is unavailable, so its template params could not be derived",
       },
     ]);
@@ -249,7 +281,11 @@ describe("problems", () => {
 
     expect(walk.entries).toEqual([]);
     expect(walk.problems).toEqual([
-      { blockId: "odd", error: `templateParams() must return an object, got ${expected}` },
+      {
+        blockId: "odd",
+        blockLabel: "odd",
+        error: `templateParams() must return an object, got ${expected}`,
+      },
     ]);
   });
 });

package/src/model/template_export.ts

@@ -20,6 +20,9 @@ export type TemplateExportEntry = {
    * already stored in params need no translation.
    */
   readonly blockId: string;
+  /** The block's label from the project structure, carried so a problem found downstream can
+   *  name the block to a person. Not written to the template. */
+  readonly blockLabel: string;
   /**
    * The block's params exactly as it projected them.
    *
@@ -33,6 +36,9 @@ export type TemplateExportEntry = {
 /** Why one block could not be exported. */
 export type TemplateExportProblem = {
   readonly blockId: string;
+  /** The block's label as the project structure holds it. An id means nothing to the person who
+   *  pressed Export; this is what a UI shows. */
+  readonly blockLabel: string;
   readonly error: string;
 };
 
@@ -91,19 +97,20 @@ export function walkProjectForTemplateExport(
   const entries: TemplateExportEntry[] = [];
   const problems: TemplateExportProblem[] = [];
 
-  for (const { id } of allBlocks(structure)) {
+  for (const { id, label } of allBlocks(structure)) {
     const derived = paramsProvider(id);
 
     if (derived === undefined) {
       problems.push({
         blockId: id,
+        blockLabel: label,
         error: "Block state is unavailable, so its template params could not be derived",
       });
       continue;
     }
 
     if (derived.error !== undefined) {
-      problems.push({ blockId: id, error: derived.error });
+      problems.push({ blockId: id, blockLabel: label, error: derived.error });
       continue;
     }
 
@@ -117,12 +124,13 @@ export function walkProjectForTemplateExport(
     if (typeof params !== "object" || params === null || Array.isArray(params)) {
       problems.push({
         blockId: id,
+        blockLabel: label,
         error: `templateParams() must return an object, got ${typeName(params)}`,
       });
       continue;
     }
 
-    entries.push({ blockId: id, params: params as Record<string, unknown> });
+    entries.push({ blockId: id, blockLabel: label, params: params as Record<string, unknown> });
   }
 
   return { entries, problems };

package/src/model/template_serializer.test.ts

@@ -198,6 +198,27 @@ describe("problems", () => {
     expect(result.problems[0].error).toContain("declares no kind");
   });
 
+  test("a problem raised here carries the block's label from the walk", () => {
+    // Labels distinct from ids, or the assertion could not tell a label carried through from
+    // an id copied into the field.
+    const structure: ProjectStructure = {
+      groups: [
+        {
+          id: "g1",
+          label: "G1",
+          blocks: [{ id: "legacy", label: "Old Aligner", renderingMode: "Heavy" }],
+        },
+      ],
+    };
+    const result = exportOf(structure, { legacy: ok({}) }, () => undefined);
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.problems).toEqual([
+      { blockId: "legacy", blockLabel: "Old Aligner", error: expect.stringContaining("no kind") },
+    ]);
+  });
+
   test("a malformed stored kind reference is a problem, not a throw", () => {
     const result = exportOf(
       simpleStructure("a"),
@@ -385,14 +406,16 @@ describe("assembleProjectTemplateV1", () => {
   test("carries the walk's problems through unchanged", () => {
     const { document, problems } = assembleProjectTemplateV1(
       {
-        entries: [{ blockId: "a", params: {} }],
-        problems: [{ blockId: "ghost", error: "state unavailable" }],
+        entries: [{ blockId: "a", blockLabel: "a", params: {} }],
+        problems: [{ blockId: "ghost", blockLabel: "ghost", error: "state unavailable" }],
       },
       kindPerBlock,
       () => registrySpec,
     );
 
-    expect(problems).toEqual([{ blockId: "ghost", error: "state unavailable" }]);
+    expect(problems).toEqual([
+      { blockId: "ghost", blockLabel: "ghost", error: "state unavailable" },
+    ]);
     expect(document.blocks.map((b) => b.id)).toEqual(["a"]);
   });
 });

package/src/model/template_serializer.ts

@@ -126,6 +126,7 @@ export function assembleProjectTemplateV1(
     if (kind === undefined) {
       problems.push({
         blockId: entry.blockId,
+        blockLabel: entry.blockLabel,
         error:
           "Block declares no kind, so it cannot be written to a template: an entry's kind " +
           "carries the params contract the entry is typed against",
@@ -143,6 +144,7 @@ export function assembleProjectTemplateV1(
     } catch (e) {
       problems.push({
         blockId: entry.blockId,
+        blockLabel: entry.blockLabel,
         error: `Block's stored kind reference is malformed: ${e instanceof Error ? e.message : String(e)}`,
       });
       continue;

package/dist/model/template_share.cjs

@@ -1,42 +0,0 @@
-let _milaboratories_pl_model_common = require("@milaboratories/pl-model-common");
-//#region src/model/template_share.ts
-/**
-* Every entry of a template that cannot travel to another machine, or an empty list for a
-* template that can be shared.
-*
-* An entry's `location` names a place rather than a name, and a `file:` place is a folder on
-* the author's own disk: a recipient resolving it finds nothing, or worse finds something
-* else. Such a template stays perfectly usable where it was made, so it is stored and applied
-* as normal — only sharing it is refused.
-*
-* A location whose scheme cannot be read is refused for the same reason: nothing can resolve
-* it anywhere, here included.
-*
-* Every offending entry is reported, not only the first, so a UI can name each block instead
-* of sending its user round the loop once per entry.
-*/
-function unshareableTemplateEntries(document) {
-	const problems = [];
-	for (const entry of document.blocks) {
-		if (entry.location === void 0) continue;
-		let scheme;
-		try {
-			scheme = (0, _milaboratories_pl_model_common.parseBlockPackLocation)(entry.location).scheme;
-		} catch (e) {
-			problems.push({
-				entryId: entry.id,
-				error: `Block is installed from a location nothing can resolve: ${e instanceof Error ? e.message : String(e)}`
-			});
-			continue;
-		}
-		if (scheme === "file") problems.push({
-			entryId: entry.id,
-			error: `Block is installed from ${entry.location}, a folder on this machine — it resolves to nothing on the recipient's, so this template cannot be shared`
-		});
-	}
-	return problems;
-}
-//#endregion
-exports.unshareableTemplateEntries = unshareableTemplateEntries;
-
-//# sourceMappingURL=template_share.cjs.map

package/dist/model/template_share.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"template_share.cjs","names":[],"sources":["../../src/model/template_share.ts"],"sourcesContent":["import type { ProjectTemplateV1 } from \"@milaboratories/pl-model-common\";\nimport { parseBlockPackLocation } from \"@milaboratories/pl-model-common\";\n\n/** One template entry standing in the way of sharing the template, and why. */\nexport type TemplateShareProblem = {\n  /** The template-local id of the entry the problem belongs to; on an exported template it is\n   *  the block's project-local uuid. */\n  readonly entryId: string;\n  readonly error: string;\n};\n\n/**\n * Every entry of a template that cannot travel to another machine, or an empty list for a\n * template that can be shared.\n *\n * An entry's `location` names a place rather than a name, and a `file:` place is a folder on\n * the author's own disk: a recipient resolving it finds nothing, or worse finds something\n * else. Such a template stays perfectly usable where it was made, so it is stored and applied\n * as normal — only sharing it is refused.\n *\n * A location whose scheme cannot be read is refused for the same reason: nothing can resolve\n * it anywhere, here included.\n *\n * Every offending entry is reported, not only the first, so a UI can name each block instead\n * of sending its user round the loop once per entry.\n */\nexport function unshareableTemplateEntries(\n  document: ProjectTemplateV1,\n): readonly TemplateShareProblem[] {\n  const problems: TemplateShareProblem[] = [];\n  for (const entry of document.blocks) {\n    if (entry.location === undefined) continue;\n    let scheme: string;\n    try {\n      scheme = parseBlockPackLocation(entry.location).scheme;\n    } catch (e) {\n      problems.push({\n        entryId: entry.id,\n        error: `Block is installed from a location nothing can resolve: ${e instanceof Error ? e.message : String(e)}`,\n      });\n      continue;\n    }\n    if (scheme === \"file\")\n      problems.push({\n        entryId: entry.id,\n        error:\n          `Block is installed from ${entry.location}, a folder on this machine — it resolves ` +\n          \"to nothing on the recipient's, so this template cannot be shared\",\n      });\n  }\n  return problems;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA0BA,SAAgB,2BACd,UACiC;CACjC,MAAM,WAAmC,CAAC;CAC1C,KAAK,MAAM,SAAS,SAAS,QAAQ;EACnC,IAAI,MAAM,aAAa,KAAA,GAAW;EAClC,IAAI;EACJ,IAAI;GACF,UAAA,GAAA,gCAAA,uBAAA,CAAgC,MAAM,QAAQ,CAAC,CAAC;EAClD,SAAS,GAAG;GACV,SAAS,KAAK;IACZ,SAAS,MAAM;IACf,OAAO,2DAA2D,aAAa,QAAQ,EAAE,UAAU,OAAO,CAAC;GAC7G,CAAC;GACD;EACF;EACA,IAAI,WAAW,QACb,SAAS,KAAK;GACZ,SAAS,MAAM;GACf,OACE,2BAA2B,MAAM,SAAS;EAE9C,CAAC;CACL;CACA,OAAO;AACT"}

package/dist/model/template_share.d.ts

@@ -1,27 +0,0 @@
-import { ProjectTemplateV1 } from "@milaboratories/pl-model-common";
-//#region src/model/template_share.d.ts
-/** One template entry standing in the way of sharing the template, and why. */
-export type TemplateShareProblem = {
-  /** The template-local id of the entry the problem belongs to; on an exported template it is
-   *  the block's project-local uuid. */
-  readonly entryId: string;
-  readonly error: string;
-};
-/**
- * Every entry of a template that cannot travel to another machine, or an empty list for a
- * template that can be shared.
- *
- * An entry's `location` names a place rather than a name, and a `file:` place is a folder on
- * the author's own disk: a recipient resolving it finds nothing, or worse finds something
- * else. Such a template stays perfectly usable where it was made, so it is stored and applied
- * as normal — only sharing it is refused.
- *
- * A location whose scheme cannot be read is refused for the same reason: nothing can resolve
- * it anywhere, here included.
- *
- * Every offending entry is reported, not only the first, so a UI can name each block instead
- * of sending its user round the loop once per entry.
- */
-export declare function unshareableTemplateEntries(document: ProjectTemplateV1): readonly TemplateShareProblem[];
-//#endregion
-//# sourceMappingURL=template_share.d.ts.map

package/dist/model/template_share.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"template_share.d.ts","names":[],"sources":["../../src/model/template_share.ts"],"mappings":";;;YAIY;;;WAGD;WACA;;;;;;;;;;;;;;;;;wBAkBK,2BACd,UAAU,6BACA"}

package/dist/model/template_share.js

@@ -1,42 +0,0 @@
-import { parseBlockPackLocation } from "@milaboratories/pl-model-common";
-//#region src/model/template_share.ts
-/**
-* Every entry of a template that cannot travel to another machine, or an empty list for a
-* template that can be shared.
-*
-* An entry's `location` names a place rather than a name, and a `file:` place is a folder on
-* the author's own disk: a recipient resolving it finds nothing, or worse finds something
-* else. Such a template stays perfectly usable where it was made, so it is stored and applied
-* as normal — only sharing it is refused.
-*
-* A location whose scheme cannot be read is refused for the same reason: nothing can resolve
-* it anywhere, here included.
-*
-* Every offending entry is reported, not only the first, so a UI can name each block instead
-* of sending its user round the loop once per entry.
-*/
-function unshareableTemplateEntries(document) {
-	const problems = [];
-	for (const entry of document.blocks) {
-		if (entry.location === void 0) continue;
-		let scheme;
-		try {
-			scheme = parseBlockPackLocation(entry.location).scheme;
-		} catch (e) {
-			problems.push({
-				entryId: entry.id,
-				error: `Block is installed from a location nothing can resolve: ${e instanceof Error ? e.message : String(e)}`
-			});
-			continue;
-		}
-		if (scheme === "file") problems.push({
-			entryId: entry.id,
-			error: `Block is installed from ${entry.location}, a folder on this machine — it resolves to nothing on the recipient's, so this template cannot be shared`
-		});
-	}
-	return problems;
-}
-//#endregion
-export { unshareableTemplateEntries };
-
-//# sourceMappingURL=template_share.js.map

package/dist/model/template_share.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"template_share.js","names":[],"sources":["../../src/model/template_share.ts"],"sourcesContent":["import type { ProjectTemplateV1 } from \"@milaboratories/pl-model-common\";\nimport { parseBlockPackLocation } from \"@milaboratories/pl-model-common\";\n\n/** One template entry standing in the way of sharing the template, and why. */\nexport type TemplateShareProblem = {\n  /** The template-local id of the entry the problem belongs to; on an exported template it is\n   *  the block's project-local uuid. */\n  readonly entryId: string;\n  readonly error: string;\n};\n\n/**\n * Every entry of a template that cannot travel to another machine, or an empty list for a\n * template that can be shared.\n *\n * An entry's `location` names a place rather than a name, and a `file:` place is a folder on\n * the author's own disk: a recipient resolving it finds nothing, or worse finds something\n * else. Such a template stays perfectly usable where it was made, so it is stored and applied\n * as normal — only sharing it is refused.\n *\n * A location whose scheme cannot be read is refused for the same reason: nothing can resolve\n * it anywhere, here included.\n *\n * Every offending entry is reported, not only the first, so a UI can name each block instead\n * of sending its user round the loop once per entry.\n */\nexport function unshareableTemplateEntries(\n  document: ProjectTemplateV1,\n): readonly TemplateShareProblem[] {\n  const problems: TemplateShareProblem[] = [];\n  for (const entry of document.blocks) {\n    if (entry.location === undefined) continue;\n    let scheme: string;\n    try {\n      scheme = parseBlockPackLocation(entry.location).scheme;\n    } catch (e) {\n      problems.push({\n        entryId: entry.id,\n        error: `Block is installed from a location nothing can resolve: ${e instanceof Error ? e.message : String(e)}`,\n      });\n      continue;\n    }\n    if (scheme === \"file\")\n      problems.push({\n        entryId: entry.id,\n        error:\n          `Block is installed from ${entry.location}, a folder on this machine — it resolves ` +\n          \"to nothing on the recipient's, so this template cannot be shared\",\n      });\n  }\n  return problems;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA0BA,SAAgB,2BACd,UACiC;CACjC,MAAM,WAAmC,CAAC;CAC1C,KAAK,MAAM,SAAS,SAAS,QAAQ;EACnC,IAAI,MAAM,aAAa,KAAA,GAAW;EAClC,IAAI;EACJ,IAAI;GACF,SAAS,uBAAuB,MAAM,QAAQ,CAAC,CAAC;EAClD,SAAS,GAAG;GACV,SAAS,KAAK;IACZ,SAAS,MAAM;IACf,OAAO,2DAA2D,aAAa,QAAQ,EAAE,UAAU,OAAO,CAAC;GAC7G,CAAC;GACD;EACF;EACA,IAAI,WAAW,QACb,SAAS,KAAK;GACZ,SAAS,MAAM;GACf,OACE,2BAA2B,MAAM,SAAS;EAE9C,CAAC;CACL;CACA,OAAO;AACT"}