@milaboratories/pl-middle-layer 1.67.5 → 1.68.0

package/dist/model/sharing_model.d.ts

@@ -1,6 +1,5 @@
 import { Branded, ProjectId } from "@milaboratories/pl-model-common";
 import { ResourceType, Role } from "@milaboratories/pl-client";
-
 //#region src/model/sharing_model.d.ts
 /**
  * Logical identity of a share, stable across replaces. A donor-generated UUID string,
@@ -9,33 +8,33 @@ import { ResourceType, Role } from "@milaboratories/pl-client";
  * {@link EnvelopeData} or by parsing a `decision/{shareId}` field name) and threads it
  * through unchanged.
  */
-type ShareId = Branded<string, "ShareId">;
+export type ShareId = Branded<string, "ShareId">;
 /** Mints a fresh {@link ShareId}. The single place a share's logical identity is created. */
-declare function newShareId(): ShareId;
+export declare function newShareId(): ShareId;
 /** Brands a string already known to be a share id (e.g. parsed from a `decision/{shareId}`
  *  field name) as a {@link ShareId}, without minting a new one. */
-declare function asShareId(id: string): ShareId;
+export declare function asShareId(id: string): ShareId;
 /** Field on the donor's clientRoot holding the {@link SharingOutboxResourceType} resource. */
-declare const SharingOutboxField = "sharingOutbox";
+export declare const SharingOutboxField = "sharingOutbox";
 /** Field on the acceptor's clientRoot holding the {@link SharingStateResourceType} resource. */
-declare const SharingStateField = "sharingState";
-declare const SharingOutboxResourceType: ResourceType;
-declare const SharedEnvelopeResourceType: ResourceType;
-declare const SharingStateResourceType: ResourceType;
-type EnvelopeMode = "copy" | "read-only" | "collaboration";
+export declare const SharingStateField = "sharingState";
+export declare const SharingOutboxResourceType: ResourceType;
+export declare const SharedEnvelopeResourceType: ResourceType;
+export declare const SharingStateResourceType: ResourceType;
+export type EnvelopeMode = "copy" | "read-only" | "collaboration";
 /** Per-project decision on change, matching the UI labels: re-snapshot the live source ("update"),
  *  carry the existing snapshot ("keep"), or drop the project from the pack ("remove"). */
-type ProjectChangeAction = "keep" | "update" | "remove";
+export type ProjectChangeAction = "keep" | "update" | "remove";
 /** Key of the per-project envelope maps: a uuid minted per snapshot to name the `project/{uuid}`
  *  field. Distinct from {@link ProjectId} — re-snapshotting one source yields a new uuid each time. */
-type ProjectFieldUuid = Branded<string, "ProjectFieldUuid">;
+export type ProjectFieldUuid = Branded<string, "ProjectFieldUuid">;
 /**
  * Whether a role may make a resource public (grant to everyone): true for controller,
  * admin; false for workflow and unspecified. The middle layer carries no policy
  * of its own here — a crafted call still hits the backend's role + permission-ceiling gate.
  * `null` (no-auth mode) returns false.
  */
-declare function canGrantToEveryone(role: Role | null): boolean;
+export declare function canGrantToEveryone(role: Role | null): boolean;
 /**
  * Whether a role may impersonate another user: open/create another user's root and list
  * the resources that user can access. Mirrors the backend's authorization rule
@@ -45,15 +44,15 @@ declare function canGrantToEveryone(role: Role | null): boolean;
  * may share their own projects, but must never be offered impersonation). `null` (no-auth
  * mode) returns false.
  */
-declare function canImpersonate(role: Role | null): boolean;
+export declare function canImpersonate(role: Role | null): boolean;
 /** One project's snapshot inside an envelope, keyed by {@link ProjectFieldUuid} in {@link EnvelopeData.projects}. */
-interface EnvelopeProject {
+export interface EnvelopeProject {
   label: string;
   source: ProjectId;
   updatedAt: number;
 }
 /** Immutable `data` on a SharedEnvelope, set at createEphemeral, never mutated. */
-interface EnvelopeData {
+export interface EnvelopeData {
   schemaVersion: 1;
   shareId: ShareId;
   sharedAt: number;
@@ -64,8 +63,8 @@ interface EnvelopeData {
   projects: Record<ProjectFieldUuid, EnvelopeProject>;
 }
 /** Dynamic field on SharingState, one per handled share, keyed by shareId. */
-declare const decisionField: (shareId: ShareId) => string;
-interface SharingDecision {
+export declare const decisionField: (shareId: ShareId) => string;
+export interface SharingDecision {
   decision: "accepted" | "rejected";
   timestamp: number;
   envelopeSharedAt: number;
@@ -78,11 +77,11 @@ interface SharingDecision {
  *  who responded and when. Informational, not authoritative (a writable grant holder
  *  could write under another login — same trust assumption as the sender field).
  *  Copied forward when a share is changed. */
-declare const AcceptanceFieldPrefix = "acceptance/";
-declare const acceptanceField: (login: string) => string;
-declare const isAcceptanceField: (name: string) => boolean;
-declare const acceptanceFieldLogin: (name: string) => string;
-interface EnvelopeAcceptance {
+export declare const AcceptanceFieldPrefix = "acceptance/";
+export declare const acceptanceField: (login: string) => string;
+export declare const isAcceptanceField: (name: string) => boolean;
+export declare const acceptanceFieldLogin: (name: string) => string;
+export interface EnvelopeAcceptance {
   action: "accepted" | "rejected";
   timestamp: number;
 }
@@ -92,7 +91,7 @@ interface EnvelopeAcceptance {
  * `data` byte buffer (the basic-resource read path) goes through here. The reactive tree-node
  * path uses `node.getDataAsJson<EnvelopeData>()`, which decodes the same JSON.
  */
-declare function decodeEnvelopeData(data: Uint8Array): EnvelopeData;
+export declare function decodeEnvelopeData(data: Uint8Array): EnvelopeData;
 /**
  * Options for {@link MiddleLayer.shareProjects}.
  *
@@ -101,7 +100,7 @@ declare function decodeEnvelopeData(data: Uint8Array): EnvelopeData;
  * `expiresAt` is set to `null`, so it never expires); the recipients variant grants each
  * named recipient and the envelope expires after the default TTL.
  */
-type ShareProjectsOptions = {
+export type ShareProjectsOptions = {
   recipients: string[];
   title: string;
   mode: EnvelopeMode;
@@ -118,5 +117,4 @@ type ShareProjectsOptions = {
   mode: EnvelopeMode;
 };
 //#endregion
-export { AcceptanceFieldPrefix, EnvelopeAcceptance, EnvelopeData, EnvelopeMode, EnvelopeProject, ProjectChangeAction, ProjectFieldUuid, ShareId, ShareProjectsOptions, SharedEnvelopeResourceType, SharingDecision, SharingOutboxField, SharingOutboxResourceType, SharingStateField, SharingStateResourceType, acceptanceField, acceptanceFieldLogin, asShareId, canGrantToEveryone, canImpersonate, decisionField, decodeEnvelopeData, isAcceptanceField, newShareId };
 //# sourceMappingURL=sharing_model.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sharing_model.d.ts","names":[],"sources":["../../src/model/sharing_model.ts"],"mappings":";;;;;;AAYA;;;;AAA6B;KAAjB,OAAA,GAAU,OAAO;;iBAGb,UAAA,IAAc,OAAO;;AAAA;iBAMrB,SAAA,CAAU,EAAA,WAAa,OAAO;;cAYjC,kBAAA;;cAEA,iBAAA;AAAA,cAEA,yBAAA,EAA2B,YAAsD;AAAA,cACjF,0BAAA,EAA4B,YAAuD;AAAA,cACnF,wBAAA,EAA0B,YAAqD;AAAA,KAEhF,YAAA;AARmB;AAE/B;AAF+B,KAYnB,mBAAA;;;KAIA,gBAAA,GAAmB,OAAO;AAZtC;;;;AAA8F;AAC9F;AADA,iBAoBgB,kBAAA,CAAmB,IAAiB,EAAX,IAAI;;;AAnBmD;AAChG;;;;AAA4F;AAE5F;iBAmCgB,cAAA,CAAe,IAAiB,EAAX,IAAI;;UAWxB,eAAA;EACf,KAAA;EACA,MAAA,EAAQ,SAAS;EACjB,SAAA;AAAA;;UAIe,YAAA;EACf,aAAA;EACA,OAAA,EAAS,OAAA;EACT,QAAA;EACA,SAAA;EACA,IAAA,EAAM,YAAA;EACN,MAAA;EACA,KAAA;EACA,QAAA,EAAU,MAAA,CAAO,gBAAA,EAAkB,eAAA;AAAA;AA7Ce;AAAA,cAiDvC,aAAA,GAAiB,OAAgB,EAAP,OAAO;AAAA,UAE7B,eAAA;EACf,QAAA;EACA,SAAA;EACA,gBAAA;EACA,gBAAA;AAAA;;;;;;;;cAUW,qBAAA;AAAA,cACA,eAAA,GAAmB,KAAa;AAAA,cAChC,iBAAA,GAAqB,IAAY;AAAA,cACjC,oBAAA,GAAwB,IAAY;AAAA,UAEhC,kBAAA;EACf,MAAA;EACA,SAAS;AAAA;;;;;;;iBASK,kBAAA,CAAmB,IAAA,EAAM,UAAA,GAAa,YAAY;;;;;;;;;KAYtD,oBAAA;EAEN,UAAA;EACA,KAAA;EACA,IAAA,EAAM,YAAA;AAAA;EAGN,QAAA;EAnDiC;AAAO;AAE9C;;;;EAwDM,OAAA;EACA,KAAA;EACA,IAAA,EAAM,YAAY;AAAA"}
+{"version":3,"file":"sharing_model.d.ts","names":[],"sources":["../../src/model/sharing_model.ts"],"mappings":";;;;;;;;;;YAYY,UAAU;;wBAGN,cAAc;;;wBAMd,UAAU,aAAa;;qBAY1B;;qBAEA;qBAEA,2BAA2B;qBAC3B,4BAA4B;qBAC5B,0BAA0B;YAE3B;;;YAIA;;;YAIA,mBAAmB;;;;;;;wBAQf,mBAAmB,MAAM;;;;;;;;;;wBAmBzB,eAAe,MAAM;;iBAWpB;EACf;EACA,QAAQ;EACR;;;iBAIe;EACf;EACA,SAAS;EACT;EACA;EACA,MAAM;EACN;EACA;EACA,UAAU,OAAO,kBAAkB;;;qBAIxB,gBAAa,SAAa;iBAEtB;EACf;EACA;EACA;EACA;;;;;;;;;qBAUW;qBACA,kBAAe;qBACf,oBAAiB;qBACjB,uBAAoB;iBAEhB;EACf;EACA;;;;;;;;wBASc,mBAAmB,MAAM,aAAa;;;;;;;;;YAY1C;EAEN;EACA;EACA,MAAM;;EAGN;;;;;;;EAOA;EACA;EACA,MAAM"}

package/dist/model/template_apply.d.ts

@@ -1,5 +1,4 @@
 import { BlockKindReference, BlockKindSelectorReference } from "@milaboratories/pl-model-common";
-
 //#region src/model/template_apply.d.ts
 /**
  * One entry the file describes in a way this project cannot honour.
@@ -10,7 +9,7 @@ import { BlockKindReference, BlockKindSelectorReference } from "@milaboratories/
  * it into a {@link TemplateApplyProblem}; anything else reaching that caller is an outage
  * rather than a statement about the file, and keeps propagating.
  */
-declare class TemplateEntryRejected extends Error {
+export declare class TemplateEntryRejected extends Error {
   readonly entryId: string;
   constructor(entryId: string, message: string);
 }
@@ -22,13 +21,16 @@ declare class TemplateEntryRejected extends Error {
  * their file each problem belongs to. `error` is a finished sentence for the person
  * who applied the file, not a code.
  */
-type TemplateApplyProblem = {
-  /** The template-local id of the entry the problem belongs to. */readonly entryId: string;
+export type TemplateApplyProblem = {
+  /** The template-local id of the entry the problem belongs to. */
+  readonly entryId: string;
   readonly error: string;
 };
 /** One entry that made it into the project. */
-type AppliedEntry = {
-  /** The entry's id in the file. */readonly templateLocalId: string; /** The project-local id the block was given. */
+export type AppliedEntry = {
+  /** The entry's id in the file. */
+  readonly templateLocalId: string;
+  /** The project-local id the block was given. */
   readonly blockId: string;
 };
 /**
@@ -41,10 +43,9 @@ type AppliedEntry = {
  * A stage that checks reports every problem it found, so a file with three mistakes takes one
  * pass to fix. Placement stops at the first one — hence at most one problem from there.
  */
-type TemplateApplyReport = {
+export type TemplateApplyReport = {
   readonly added: readonly AppliedEntry[];
   readonly problems: readonly TemplateApplyProblem[];
 };
 //#endregion
-export { AppliedEntry, TemplateApplyProblem, TemplateApplyReport, TemplateEntryRejected };
 //# sourceMappingURL=template_apply.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"template_apply.d.ts","names":[],"sources":["../../src/model/template_apply.ts"],"mappings":";;;;;AAkBA;;;;;;;cAAa,qBAAA,SAA8B,KAAK;EAAA,SAEnC,OAAA;cAAA,OAAA,UACT,OAAA;AAAA;AAeJ;;;;AAGgB;AAIhB;;;AAPA,KAAY,oBAAA;EAWM,0EATP,OAAA;EAAA,SACA,KAAK;AAAA;;KAIJ,YAAA;EAkBe,2CAhBhB,eAAA,UAiBmB;EAAA,SAfnB,OAAO;AAAA;;;;;;;;;;;KAaN,mBAAA;EAAA,SACD,KAAA,WAAgB,YAAA;EAAA,SAChB,QAAA,WAAmB,oBAAoB;AAAA"}
+{"version":3,"file":"template_apply.d.ts","names":[],"sources":["../../src/model/template_apply.ts"],"mappings":";;;;;;;;;;;qBAkBa,8BAA8B;WAE9B;EADX,YACW,iBACT;;;;;;;;;;YAeQ;;WAED;WACA;;;YAIC;;WAED;;WAEA;;;;;;;;;;;;YAaC;WACD,gBAAgB;WAChB,mBAAmB"}

package/dist/model/template_export.d.ts

@@ -1,9 +1,9 @@
+import "./project_model.js";
 //#region src/model/template_export.d.ts
 /** Why one block could not be exported. */
-type TemplateExportProblem = {
+export type TemplateExportProblem = {
   readonly blockId: string;
   readonly error: string;
 };
 //#endregion
-export { TemplateExportProblem };
 //# sourceMappingURL=template_export.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"template_export.d.ts","names":[],"sources":["../../src/model/template_export.ts"],"mappings":";;KAiCY,qBAAA;EAAA,SACD,OAAA;EAAA,SACA,KAAK;AAAA"}
+{"version":3,"file":"template_export.d.ts","names":[],"sources":["../../src/model/template_export.ts"],"mappings":";;;YAiCY;WACD;WACA"}

package/dist/model/template_parser.d.ts

@@ -1,5 +1,4 @@
 import { ProjectTemplateV1 } from "@milaboratories/pl-model-common";
-
 //#region src/model/template_parser.d.ts
 /**
  * A template file read, or why it could not be.
@@ -10,7 +9,7 @@ import { ProjectTemplateV1 } from "@milaboratories/pl-model-common";
  * after this one. The message may span several lines when the file has several
  * fixable issues, so that fixing it takes one pass.
  */
-type TemplateParseOutcome = {
+export type TemplateParseOutcome = {
   readonly ok: true;
   readonly document: ProjectTemplateV1;
 } | {
@@ -37,7 +36,6 @@ type TemplateParseOutcome = {
  * Nothing here checks that references point anywhere or that a kind can be resolved —
  * those are later stages, and both need more than the file to answer.
  */
-declare function parseProjectTemplateV1Yaml(text: string): TemplateParseOutcome;
+export declare function parseProjectTemplateV1Yaml(text: string): TemplateParseOutcome;
 //#endregion
-export { TemplateParseOutcome, parseProjectTemplateV1Yaml };
 //# sourceMappingURL=template_parser.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"template_parser.d.ts","names":[],"sources":["../../src/model/template_parser.ts"],"mappings":";;;;;AAiBA;;;;;;;KAAY,oBAAA;EAAA,SACG,EAAA;EAAA,SAAmB,QAAA,EAAU,iBAAiB;AAAA;EAAA,SAC9C,EAAA;EAAA,SAAoB,KAAA;AAAA;;AAsB2C;;;;;;;;;;;;;;;;;;;iBAA9D,0BAAA,CAA2B,IAAA,WAAe,oBAAoB"}
+{"version":3,"file":"template_parser.d.ts","names":[],"sources":["../../src/model/template_parser.ts"],"mappings":";;;;;;;;;;;YAiBY;WACG;WAAmB,UAAU;;WAC7B;WAAoB;;;;;;;;;;;;;;;;;;;;;;wBAsBnB,2BAA2B,eAAe"}

package/dist/model/template_resolve.d.ts

@@ -1,7 +1,6 @@
 import { TemplateApplyProblem } from "./template_apply.js";
 import { BlockPackId, BlockPackSpec } from "@milaboratories/pl-model-middle-layer";
 import { BlockKindSelectorReference, BlockPackLocationReference, ProjectTemplateV1 } from "@milaboratories/pl-model-common";
-
 //#region src/model/template_resolve.d.ts
 /**
  * Where a template entry's block comes from.
@@ -24,7 +23,7 @@ import { BlockKindSelectorReference, BlockPackLocationReference, ProjectTemplate
  * for it at all, and the fallbacks it could invent are all wrong. See
  * {@link ResolvedEntry}'s `title`.
  */
-type BlockPackProvider = {
+export type BlockPackProvider = {
   /**
    * Find the block implementing a kind selector.
    *
@@ -72,7 +71,7 @@ type BlockPackProvider = {
  *   apply did not allow unstable ones. This is the only reason the user can act on
  *   without editing anything.
  */
-type KindResolution = {
+export type KindResolution = {
   readonly ok: true;
   readonly spec: BlockPackSpec;
   readonly title: string;
@@ -81,7 +80,7 @@ type KindResolution = {
   readonly reason: "no-matching-kind-version" | "no-implementation" | "no-stable-implementation";
 };
 /** The outcome of locating one exact block version. */
-type ExactResolution = {
+export type ExactResolution = {
   readonly ok: true;
   readonly spec: BlockPackSpec;
   readonly title: string;
@@ -102,7 +101,7 @@ type ExactResolution = {
  * - `not-a-block` — something is there, but it is not a block. Usually a path pointing
  *   one directory off, which is why the message has to say what was looked for.
  */
-type LocationResolution = {
+export type LocationResolution = {
   readonly ok: true;
   readonly spec: BlockPackSpec;
   readonly title: string;
@@ -111,8 +110,9 @@ type LocationResolution = {
   readonly reason: "unsupported-scheme" | "not-found" | "not-a-block";
 };
 /** Where one entry's block will come from. */
-type ResolvedEntry = {
-  /** The entry's template-local id. */readonly entryId: string;
+export type ResolvedEntry = {
+  /** The entry's template-local id. */
+  readonly entryId: string;
   readonly spec: BlockPackSpec;
   /**
    * The block package's own title, as its author published it — `meta.title` for a
@@ -147,7 +147,7 @@ type ResolvedEntry = {
  * resolution: the point of resolving before construction is that nothing is created
  * until every entry has an implementation.
  */
-type TemplateResolveOutcome = {
+export type TemplateResolveOutcome = {
   readonly resolved: readonly ResolvedEntry[];
   readonly problems: readonly TemplateApplyProblem[];
 };
@@ -167,7 +167,7 @@ type TemplateResolveOutcome = {
  * @param provider Where blocks come from
  * @param options `allowUnstable` applies to the whole document, not per entry
  */
-declare function resolveTemplateEntries(document: ProjectTemplateV1, provider: BlockPackProvider, options: {
+export declare function resolveTemplateEntries(document: ProjectTemplateV1, provider: BlockPackProvider, options: {
   allowUnstable: boolean;
 }): Promise<TemplateResolveOutcome>;
 /**
@@ -184,10 +184,9 @@ declare function resolveTemplateEntries(document: ProjectTemplateV1, provider: B
  *
  * @throws if the name has no npm scope or no organization segment
  */
-declare function parseBlockPackName(npmName: string): {
+export declare function parseBlockPackName(npmName: string): {
   organization: string;
   name: string;
 };
 //#endregion
-export { BlockPackProvider, ExactResolution, KindResolution, LocationResolution, ResolvedEntry, TemplateResolveOutcome, parseBlockPackName, resolveTemplateEntries };
 //# sourceMappingURL=template_resolve.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"template_resolve.d.ts","names":[],"sources":["../../src/model/template_resolve.ts"],"mappings":";;;;;;;AAkCA;;;;;;;;;;;;;;;;;;;KAAY,iBAAA;EAWG;;;;;;;EAHb,MAAA,GACE,IAAA,EAAM,0BAAA,EACN,OAAA;IAAW,aAAA;EAAA,MACR,OAAA,CAAQ,cAAA;EAwBiD;;AAAkB;AAiBlF;;;;EAhCE,cAAA,GAAiB,EAAA,EAAI,WAAA,KAAgB,OAAA,CAAQ,eAAA;EAiCb;;;;;;AAGb;AAOrB;;;;;;EA5BE,UAAA,GAAa,QAAA,EAAU,0BAAA,KAA+B,OAAA,CAAQ,kBAAA;AAAA;;;;AA8BvB;AAezC;;;;;;;;;;KA5BY,cAAA;EAAA,SACG,EAAA;EAAA,SAAmB,IAAA,EAAM,aAAa;EAAA,SAAW,KAAA;AAAA;EAAA,SAEjD,EAAA;EAAA,SACA,MAAA;AAAA;;KAOH,eAAA;EAAA,SACG,EAAA;EAAA,SAAmB,IAAA,EAAM,aAAa;EAAA,SAAW,KAAA;AAAA;EAAA,SACjD,EAAA;EAAA,SAAoB,MAAA;AAAA;;;;;;AAmEe;AAmBlD;;;;;;;KAvEY,kBAAA;EAAA,SAEG,EAAA;EAAA,SACA,IAAA,EAAM,aAAa;EAAA,SACnB,KAAA;AAAA;EAAA,SAGA,EAAA;EAAA,SACA,MAAA;AAAA;;KAIH,aAAA;EA+DqB,8CA7DtB,OAAA;EAAA,SACA,IAAA,EAAM,aAAa;EAqMI;;;;;;;AAA+C;;;;;;;;EAA/C,SArLvB,KAAA;;;;;;;;WAQA,MAAA;AAAA;;;;;;;;;KAWC,sBAAA;EAAA,SACD,QAAA,WAAmB,aAAA;EAAA,SACnB,QAAA,WAAmB,oBAAoB;AAAA;;;;;;;;;;;;;;;;;iBAmB5B,sBAAA,CACpB,QAAA,EAAU,iBAAA,EACV,QAAA,EAAU,iBAAA,EACV,OAAA;EAAW,aAAA;AAAA,IACV,OAAA,CAAQ,sBAAA;;;;;;;;;;;;;;;iBAyIK,kBAAA,CAAmB,OAAA;EAAoB,YAAA;EAAsB,IAAA;AAAA"}
+{"version":3,"file":"template_resolve.d.ts","names":[],"sources":["../../src/model/template_resolve.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;YAkCY;;;;;;;;EAQV,SACE,MAAM,4BACN;IAAW;QACR,QAAQ;;;;;;;;EASb,iBAAiB,IAAI,gBAAgB,QAAQ;;;;;;;;;;;;;;EAe7C,aAAa,UAAU,+BAA+B,QAAQ;;;;;;;;;;;;;;;;YAiBpD;WACG;WAAmB,MAAM;WAAwB;;WAEjD;WACA;;;YAOH;WACG;WAAmB,MAAM;WAAwB;;WACjD;WAAoB;;;;;;;;;;;;;;;YAevB;WAEG;WACA,MAAM;WACN;;WAGA;WACA;;;YAIH;;WAED;WACA,MAAM;;;;;;;;;;;;;;;;WAgBN;;;;;;;;WAQA;;;;;;;;;;YAWC;WACD,mBAAmB;WACnB,mBAAmB;;;;;;;;;;;;;;;;;;wBAmBR,uBACpB,UAAU,mBACV,UAAU,mBACV;EAAW;IACV,QAAQ;;;;;;;;;;;;;;;wBAyIK,mBAAmB;EAAoB;EAAsB"}

package/dist/model/template_serializer.d.ts

@@ -1,17 +1,18 @@
+import "./project_model.js";
 import { TemplateExportProblem } from "./template_export.js";
 import { BlockPackSpec } from "@milaboratories/pl-model-middle-layer";
 import { BlockKindReference, BlockPackLocationReference, ProjectTemplateV1 } from "@milaboratories/pl-model-common";
-
 //#region src/model/template_serializer.d.ts
 /** What the caller gets back for a whole project. */
-type ProjectTemplateExportOutcome = {
+export type ProjectTemplateExportOutcome = {
   readonly ok: true;
-  readonly yaml: string; /** The document the YAML was rendered from, already validated. */
+  readonly yaml: string;
+  /** The document the YAML was rendered from, already validated. */
   readonly document: ProjectTemplateV1;
 } | {
-  readonly ok: false; /** Every block that stands in the way, not just the first. */
+  readonly ok: false;
+  /** Every block that stands in the way, not just the first. */
   readonly problems: readonly TemplateExportProblem[];
 };
 //#endregion
-export { ProjectTemplateExportOutcome };
 //# sourceMappingURL=template_serializer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"template_serializer.d.ts","names":[],"sources":["../../src/model/template_serializer.ts"],"mappings":";;;;;;KAoCY,4BAAA;EAAA,SAEG,EAAA;EAAA,SACA,IAAA,UAOwC;EAAA,SALxC,QAAA,EAAU,iBAAA;AAAA;EAAA,SAGV,EAAA;WAEA,QAAA,WAAmB,qBAAqB;AAAA"}
+{"version":3,"file":"template_serializer.d.ts","names":[],"sources":["../../src/model/template_serializer.ts"],"mappings":";;;;;;YAoCY;WAEG;WACA;;WAEA,UAAU;;WAGV;;WAEA,mBAAmB"}

package/dist/model/template_spec.d.ts

@@ -1,30 +1,28 @@
 import { SignedResourceId } from "@milaboratories/pl-client";
 import { CompiledTemplateV3, TemplateData } from "@milaboratories/pl-model-backend";
-
 //#region src/model/template_spec.d.ts
-interface TemplateFromRegistry {
+export interface TemplateFromRegistry {
   readonly type: "from-registry";
   registry: string;
   path: string;
 }
-interface ExplicitTemplate {
+export interface ExplicitTemplate {
   readonly type: "explicit";
   content: Uint8Array;
 }
-interface PreparedTemplate {
+export interface PreparedTemplate {
   readonly type: "prepared";
   data: TemplateData | CompiledTemplateV3;
 }
-interface CachedTemplate {
+export interface CachedTemplate {
   readonly type: "cached";
   readonly resourceId: SignedResourceId;
 }
-interface TemplateFromFile {
+export interface TemplateFromFile {
   readonly type: "from-file";
   path: string;
 }
-type TemplateSpecPrepared = TemplateFromRegistry | ExplicitTemplate | PreparedTemplate | CachedTemplate;
-type TemplateSpecAny = TemplateSpecPrepared | TemplateFromFile;
+export type TemplateSpecPrepared = TemplateFromRegistry | ExplicitTemplate | PreparedTemplate | CachedTemplate;
+export type TemplateSpecAny = TemplateSpecPrepared | TemplateFromFile;
 //#endregion
-export { CachedTemplate, ExplicitTemplate, PreparedTemplate, TemplateFromFile, TemplateFromRegistry, TemplateSpecAny, TemplateSpecPrepared };
 //# sourceMappingURL=template_spec.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"template_spec.d.ts","names":[],"sources":["../../src/model/template_spec.ts"],"mappings":";;;;UAGiB,oBAAA;EAAA,SACN,IAAA;EACT,QAAA;EACA,IAAA;AAAA;AAAA,UAGe,gBAAA;EAAA,SACN,IAAA;EACT,OAAA,EAAS,UAAU;AAAA;AAAA,UAGJ,gBAAA;EAAA,SACN,IAAA;EACT,IAAA,EAAM,YAAA,GAAe,kBAAkB;AAAA;AAAA,UAGxB,cAAA;EAAA,SACN,IAAA;EAAA,SACA,UAAA,EAAY,gBAAgB;AAAA;AAAA,UAGtB,gBAAA;EAAA,SACN,IAAA;EACT,IAAI;AAAA;AAAA,KAGM,oBAAA,GACR,oBAAA,GACA,gBAAA,GACA,gBAAA,GACA,cAAA;AAAA,KACQ,eAAA,GAAkB,oBAAA,GAAuB,gBAAgB"}
+{"version":3,"file":"template_spec.d.ts","names":[],"sources":["../../src/model/template_spec.ts"],"mappings":";;;iBAGiB;WACN;EACT;EACA;;iBAGe;WACN;EACT,SAAS;;iBAGM;WACN;EACT,MAAM,eAAe;;iBAGN;WACN;WACA,YAAY;;iBAGN;WACN;EACT;;YAGU,uBACR,uBACA,mBACA,mBACA;YACQ,kBAAkB,uBAAuB"}

package/dist/mutator/block-pack/block_pack.d.ts

@@ -1,12 +1,12 @@
 import { V2RegistryProvider } from "../../block_registry/registry-v2-provider.js";
 import { BlockPackSpecAny, BlockPackSpecPrepared } from "../../model/block_pack_spec.js";
+import "../../model/index.js";
 import { BlockConfigContainer } from "@platforma-sdk/model";
 import { Dispatcher } from "undici";
 import { Signer } from "@milaboratories/ts-helpers";
 import { AnyResourceRef, PlTransaction, ResourceType } from "@milaboratories/pl-client";
-
 //#region src/mutator/block-pack/block_pack.d.ts
-declare class BlockPackPreparer {
+export declare class BlockPackPreparer {
   private readonly v2RegistryProvider;
   private readonly signer;
   private readonly http?;
@@ -21,5 +21,4 @@ declare class BlockPackPreparer {
   private prepareWithoutUnpacking;
 }
 //#endregion
-export { BlockPackPreparer };
 //# sourceMappingURL=block_pack.d.ts.map

package/dist/mutator/block-pack/block_pack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block_pack.d.ts","names":[],"sources":["../../../src/mutator/block-pack/block_pack.ts"],"mappings":";;;;;;;;cA4Da,iBAAA;EAAA,iBAEQ,kBAAA;EAAA,iBACA,MAAA;EAAA,iBACA,IAAA;cAFA,kBAAA,EAAoB,kBAAA,EACpB,MAAA,EAAQ,MAAA,EACR,IAAA,GAAO,UAAA;EAAA,iBAGT,kBAAA;EAe0B;EAAA,iBAJ1B,aAAA;EAIJ,uBAAA,CAAwB,IAAA,EAAM,gBAAA,GAAmB,OAAA,CAAQ,oBAAA;EAgE3C;EAAA,QAXnB,OAAA;EAWK,OAAA,CAAQ,IAAA,EAAM,gBAAA,GAAmB,OAAA,CAAQ,qBAAA;EAAA,QAmCxC,uBAAA;AAAA"}
+{"version":3,"file":"block_pack.d.ts","names":[],"sources":["../../../src/mutator/block-pack/block_pack.ts"],"mappings":";;;;;;;;qBA4Da;mBAEQ;mBACA;mBACA;EAHnB,YACmB,oBAAoB,oBACpB,QAAQ,QACR,OAAO;mBAGT;;mBAWA;EAIJ,wBAAwB,MAAM,mBAAmB,QAAQ;;UAqD9D;EAWK,QAAQ,MAAM,mBAAmB,QAAQ;UAmCxC"}

package/dist/mutator/project.cjs

@@ -25,6 +25,10 @@ denque = require_runtime.__toESM(denque, 1);
 function isProductionFieldSettled(status) {
 	return status === "Ready" || status === "Error";
 }
+/** Either failure shape a production field can be in: no value resource, or an errored one. */
+function hasError(state) {
+	return state?.fieldError === true || state?.status === "Error";
+}
 function cached(modIdCb, valueCb) {
 	let initialized = false;
 	let lastModId = void 0;
@@ -119,8 +123,16 @@ var BlockInfo = class {
 	get productionRendered() {
 		return this.fields.prodCtx !== void 0;
 	}
+	/**
+	* True if the rendered production failed, in either shape {@link hasError} covers.
+	*
+	* Must stay in step with the `outputError` the desktop derives in
+	* `middle_layer/project_overview.ts`, because that flag is what enables the Run button.
+	* Any failure counted there but not here leaves Run enabled yet inert: `renderProduction`
+	* finds nothing to re-render and commits an empty transaction.
+	*/
 	get productionHasErrors() {
-		return this.fields.prodUiCtx?.status === "Error" || this.fields.prodOutput?.status === "Error" || this.fields.prodCtx?.status === "Error";
+		return hasError(this.fields.prodUiCtx) || hasError(this.fields.prodOutput) || hasError(this.fields.prodCtx);
 	}
 	productionStaleC = cached(() => `${this.fields.currentArgs.modCount}_${this.fields.prodArgs?.modCount}`, () => this.fields.prodArgs === void 0 || Buffer.compare(this.fields.currentArgs.value, this.fields.prodArgs.value) !== 0);
 	get requireProductionRendering() {
@@ -974,9 +986,14 @@ var ProjectMutator = class ProjectMutator {
 				};
 				blockInfoStates.set(projectField.blockId, info);
 			}
-			info.fields[projectField.fieldName] = (0, _milaboratories_pl_client.isNullSignedResourceId)(f.value) ? { modCount: 0 } : {
+			const fieldError = (0, _milaboratories_pl_client.isNotNullSignedResourceId)(f.error);
+			info.fields[projectField.fieldName] = (0, _milaboratories_pl_client.isNullSignedResourceId)(f.value) ? {
+				modCount: 0,
+				fieldError
+			} : {
 				modCount: 0,
-				ref: f.value
+				ref: f.value,
+				fieldError
 			};
 		}
 		const blockFieldRequests = [];