@milaboratories/pl-middle-layer 1.67.4 → 1.67.6

package/dist/model/block_pack_spec.d.ts

@@ -2,31 +2,30 @@ import { CachedTemplate, ExplicitTemplate, PreparedTemplate } from "./template_s
 import { BlockConfigContainer } from "@platforma-sdk/model";
 import { BlockPackSpec } from "@milaboratories/pl-model-middle-layer";
 import { ResourceType } from "@milaboratories/pl-client";
-
 //#region src/model/block_pack_spec.d.ts
-type FrontendSpec = FrontendFromUrl | FrontendFromFolder | FrontendFromLocalTgz;
-interface FrontendFromUrlData {
+export type FrontendSpec = FrontendFromUrl | FrontendFromFolder | FrontendFromLocalTgz;
+export interface FrontendFromUrlData {
   url: string;
 }
-declare const FrontendFromUrlResourceType: ResourceType;
+export declare const FrontendFromUrlResourceType: ResourceType;
 /** Directs user of the block pack to download the contents from the URL
  * outside the pl infrastructure. */
-interface FrontendFromUrl extends FrontendFromUrlData {
+export interface FrontendFromUrl extends FrontendFromUrlData {
   type: "url";
 }
-interface FrontendFromFolderData {
+export interface FrontendFromFolderData {
   path: string;
   /** HMAC signature of the path using local secret encoded as hex. */
   signature: string;
 }
-declare const FrontendFromFolderResourceType: ResourceType;
+export declare const FrontendFromFolderResourceType: ResourceType;
 /** Directs user of the block pack to load frontend from specific local
  * folder. Signature allows to confirm that this is the same client who
  * added the resource. */
-interface FrontendFromFolder extends FrontendFromFolderData {
+export interface FrontendFromFolder extends FrontendFromFolderData {
   type: "local";
 }
-interface FrontendFromLocalTgzData {
+export interface FrontendFromLocalTgzData {
   /** Absolute path to a local `ui.tgz` archive. */
   path: string;
   /** Modification stamp of the source block; part of the cache key so the
@@ -35,17 +34,17 @@ interface FrontendFromLocalTgzData {
   /** HMAC signature of `path + ":" + mtime` using local secret, encoded as hex. */
   signature: string;
 }
-declare const FrontendFromLocalTgzResourceType: ResourceType;
+export declare const FrontendFromLocalTgzResourceType: ResourceType;
 /** Directs user of the block pack to lazily unpack the frontend from a local
  * `ui.tgz` archive via the download driver — so it inherits the driver's
  * usage-tracking and space recycling (unlike `local`, which serves a folder
  * path directly). Used by the `from-pack-v2` loader for npm-consumed blocks. */
-interface FrontendFromLocalTgz extends FrontendFromLocalTgzData {
+export interface FrontendFromLocalTgz extends FrontendFromLocalTgzData {
   type: "local-tgz";
 }
 /** Direct instructions to create block-pack from client. Currently, this
  * is the only block-pack spec that can be directly materialized. */
-interface BlockPackExplicit {
+export interface BlockPackExplicit {
   type: "explicit";
   template: ExplicitTemplate;
   config: BlockConfigContainer;
@@ -53,7 +52,7 @@ interface BlockPackExplicit {
   source: BlockPackSpec;
 }
 /** Block-pack spec that can be materialized in pl. */
-type BlockPackSpecPrepared = {
+export type BlockPackSpecPrepared = {
   type: "prepared";
   template: PreparedTemplate | CachedTemplate;
   config: BlockConfigContainer;
@@ -67,7 +66,6 @@ type BlockPackSpecPrepared = {
   requiredCapabilities?: string[];
 };
 /** All block-pack specs. */
-type BlockPackSpecAny = BlockPackSpecPrepared | BlockPackExplicit | BlockPackSpec;
+export type BlockPackSpecAny = BlockPackSpecPrepared | BlockPackExplicit | BlockPackSpec;
 //#endregion
-export { BlockPackExplicit, BlockPackSpecAny, BlockPackSpecPrepared, FrontendFromFolder, FrontendFromFolderData, FrontendFromFolderResourceType, FrontendFromLocalTgz, FrontendFromLocalTgzData, FrontendFromLocalTgzResourceType, FrontendFromUrl, FrontendFromUrlData, FrontendFromUrlResourceType, FrontendSpec };
 //# sourceMappingURL=block_pack_spec.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"block_pack_spec.d.ts","names":[],"sources":["../../src/model/block_pack_spec.ts"],"mappings":";;;;;;KAKY,YAAA,GAAe,eAAA,GAAkB,kBAAA,GAAqB,oBAAA;AAAA,UAEjD,mBAAA;EACf,GAAG;AAAA;AAAA,cAGQ,2BAAA,EAA6B,YAAyD;;;UAIlF,eAAA,SAAwB,mBAAmB;EAC1D,IAAI;AAAA;AAAA,UAGW,sBAAA;EACf,IAAA;EAfgE;EAiBhE,SAAS;AAAA;AAAA,cAGE,8BAAA,EAAgC,YAG5C;;;;UAKgB,kBAAA,SAA2B,sBAAsB;EAChE,IAAI;AAAA;AAAA,UAGW,wBAAA;EA1BkF;EA4BjG,IAAA;EAxBe;;EA2Bf,KAAA;EA3BuC;EA6BvC,SAAA;AAAA;AAAA,cAGW,gCAAA,EAAkC,YAG9C;;;AA5BU;AAGX;UA+BiB,oBAAA,SAA6B,wBAAwB;EACpE,IAAI;AAAA;AA7BL;AAKD;AALC,UAkCgB,iBAAA;EACf,IAAA;EACA,QAAA,EAAU,gBAAA;EACV,MAAA,EAAQ,oBAAA;EACR,QAAA,EAAU,YAAA;EACV,MAAA,EAAQ,aAAA;AAAA;;KAIE,qBAAA;EACV,IAAA;EACA,QAAA,EAAU,gBAAA,GAAmB,cAAA;EAC7B,MAAA,EAAQ,oBAAA;EACR,QAAA,EAAU,YAAA;EACV,MAAA,EAAQ,aAAA;EA1BT;;;AAAA;AAMD;EA0BE,oBAAA;AAAA;;KAIU,gBAAA,GAAmB,qBAAA,GAAwB,iBAAA,GAAoB,aAAA"}
+{"version":3,"file":"block_pack_spec.d.ts","names":[],"sources":["../../src/model/block_pack_spec.ts"],"mappings":";;;;;YAKY,eAAe,kBAAkB,qBAAqB;iBAEjD;EACf;;qBAGW,6BAA6B;;;iBAIzB,wBAAwB;EACvC;;iBAGe;EACf;;EAEA;;qBAGW,gCAAgC;;;;iBAQ5B,2BAA2B;EAC1C;;iBAGe;;EAEf;;;EAGA;;EAEA;;qBAGW,kCAAkC;;;;;iBAS9B,6BAA6B;EAC5C;;;;iBAKe;EACf;EACA,UAAU;EACV,QAAQ;EACR,UAAU;EACV,QAAQ;;;YAIE;EACV;EACA,UAAU,mBAAmB;EAC7B,QAAQ;EACR,UAAU;EACV,QAAQ;;;;;;EAMR;;;YAIU,mBAAmB,wBAAwB,oBAAoB"}

package/dist/model/frontend.d.ts

@@ -2,12 +2,11 @@
 /** Middle layer provides information about where frontend for a specific block
  * was unpacked and basic meta information about the enclosed UI
  * (i.e. SDK version). */
-interface FrontendData {
+export interface FrontendData {
   /** URL of the frontend */
   readonly url: string;
   /** SDK version used by the UI */
   readonly sdkVersion: string;
 }
 //#endregion
-export { FrontendData };
 //# sourceMappingURL=frontend.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"frontend.d.ts","names":[],"sources":["../../src/model/frontend.ts"],"mappings":";;AAGA;;UAAiB,YAAA;EAEN;EAAA,SAAA,GAAA;;WAGA,UAAU;AAAA"}
+{"version":3,"file":"frontend.d.ts","names":[],"sources":["../../src/model/frontend.ts"],"mappings":";;;;iBAGiB;;WAEN;;WAGA"}

package/dist/model/project_helper.d.ts

@@ -4,7 +4,6 @@ import { MiLogger } from "@milaboratories/ts-helpers";
 import { StringifiedJson } from "@milaboratories/pl-model-common";
 import { SignedResourceId } from "@milaboratories/pl-client";
 import { QuickJSWASMModule } from "quickjs-emscripten";
-
 //#region src/model/project_helper.d.ts
 /**
  * Result of VM-based storage migration.
@@ -13,14 +12,14 @@ import { QuickJSWASMModule } from "quickjs-emscripten";
  * - Error result: { error: string } - serious failure (no context, etc.)
  * - Success result: { newStorageJson: StringifiedJson<BlockStorage>, info: string } - migration succeeded
  */
-type MigrationResult = {
+export type MigrationResult = {
   error: string;
 } | {
   error?: undefined;
   newStorageJson: StringifiedJson<BlockStorage>;
   info: string;
 };
-declare class ProjectHelper {
+export declare class ProjectHelper {
   private readonly quickJs;
   readonly logger: MiLogger;
   private readonly enrichmentTargetsCache;
@@ -181,5 +180,4 @@ declare class ProjectHelper {
   migrateStorageInVM(blockConfig: BlockConfig, currentStorageJson: string | undefined): MigrationResult;
 }
 //#endregion
-export { MigrationResult, ProjectHelper };
 //# sourceMappingURL=project_helper.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"project_helper.d.ts","names":[],"sources":["../../src/model/project_helper.ts"],"mappings":";;;;;;;;;;AAgCA;;;;;KAAY,eAAA;EACN,KAAA;AAAA;EACA,KAAA;EAAmB,cAAA,EAAgB,eAAe,CAAC,YAAA;EAAe,IAAA;AAAA;AAAA,cAsB3D,aAAA;EAAA,iBAaQ,OAAA;EAAA,SACD,MAAA,EAAQ,QAAA;EAAA,iBAbT,sBAAA;cAYE,OAAA,EAAS,iBAAA,EACV,MAAA,GAAQ,QAAA;EAAA;;;;;;;;;;;EAkBnB,qBAAA,CACL,WAAA,EAAa,WAAA,EACb,WAAA,WACC,aAAA;EA8NA;;;;;;;;EA9LI,2BAAA,CAA4B,WAAA,EAAa,WAAA,EAAa,WAAA;EA4Z1D;;;;;;;;;;;;;;;;;;;;;;;;;EA3WI,+BAAA,CACL,WAAA,EAAa,WAAA,EACb,WAAA,WACC,aAAA;EAAA,QAsDK,0BAAA;EAaD,oBAAA,CACL,WAAA,QAAmB,WAAA,EACnB,IAAA,iBACA,GAAA;IAAQ,OAAA,EAAS,gBAAA;IAAkB,YAAA,EAAc,gBAAA;EAAA,IAChD,KAAA;EADO;;;;;;;;;;EAsBH,qBAAA,CAAsB,WAAA,EAAa,WAAA;EA4CxC;;;;;;;;;;;;;;;;;;;;;EADK,0BAAA,CACL,WAAA,EAAa,WAAA,EACb,MAAA,YACC,aAAA;EAiLgB;;;;;;;AA6CD;;;;;;;;;;;;;;;;;;;EAzKX,+BAAA,CACL,WAAA,EAAa,WAAA,EACb,MAAA,WACA,QAAA,EAAU,WAAA,mBACT,aAAA;;;;;;;;;;;;;;EA0EI,sBAAA,CACL,WAAA,EAAa,WAAA,EACb,kBAAA,UACA,OAAA;IAAW,SAAA;IAAmB,KAAA;EAAA;;;;;;;;;EAwCzB,uBAAA,CACL,WAAA,EAAa,WAAA,EACb,cAAA,uBACC,eAAA,CAAgB,gBAAA;;;;;;;;;;;;;;;;EA0CZ,kBAAA,CACL,WAAA,EAAa,WAAA,EACb,kBAAA,uBACC,eAAA;AAAA"}
+{"version":3,"file":"project_helper.d.ts","names":[],"sources":["../../src/model/project_helper.ts"],"mappings":";;;;;;;;;;;;;;YAgCY;EACN;;EACA;EAAmB,gBAAgB,gBAAgB;EAAe;;qBAsB3D;mBAaQ;WACD,QAAQ;mBAbT;EAWjB,YACmB,SAAS,mBACV,SAAQ;;;;;;;;;;;;EAkBnB,sBACL,aAAa,aACb,sBACC;;;;;;;;;EAgCI,4BAA4B,aAAa,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;EAiDtD,gCACL,aAAa,aACb,sBACC;UAsDK;EAaD,qBACL,mBAAmB,aACnB,qBACA;IAAQ,SAAS;IAAkB,cAAc;MAChD;;;;;;;;;;;EAqBI,sBAAsB,aAAa;;;;;;;;;;;;;;;;;;;;;;EA2CnC,2BACL,aAAa,aACb,kBACC;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqDI,gCACL,aAAa,aACb,iBACA,UAAU,8BACT;;;;;;;;;;;;;;EA0EI,uBACL,aAAa,aACb,4BACA;IAAW;IAAmB;;;;;;;;;;EAwCzB,wBACL,aAAa,aACb,qCACC,gBAAgB;;;;;;;;;;;;;;;;EA0CZ,mBACL,aAAa,aACb,yCACC"}

package/dist/model/project_model.d.ts

@@ -1,25 +1,25 @@
+import "@platforma-sdk/model";
 import { ProjectListEntry, ProjectMeta } from "@milaboratories/pl-model-middle-layer";
 import { ProjectId as ProjectId$1 } from "@milaboratories/pl-model-common";
 import { ResourceType } from "@milaboratories/pl-client";
-
 //#region src/model/project_model.d.ts
 interface ProjectListEntry$1 extends Omit<ProjectListEntry, "id"> {
   /** Unique project identifier in middle layer. Use to operate with given project. */
   id: ProjectId$1;
 }
-declare const ProjectResourceType: ResourceType;
-declare const SchemaVersionKey = "SchemaVersion";
-declare const SchemaVersionCurrent = "4";
-declare const ProjectCreatedTimestamp = "ProjectCreated";
-declare const ProjectLastModifiedTimestamp = "ProjectLastModified";
-declare const ProjectMetaKey = "ProjectMeta";
-declare const ProjectStructureKey = "ProjectStructure";
-declare const BlockArgsAuthorKeyPrefix = "BlockArgsAuthor/";
-declare const ProjectStructureAuthorKey = "ProjectStructureAuthor";
-interface ProjectField {
+export declare const ProjectResourceType: ResourceType;
+export declare const SchemaVersionKey = "SchemaVersion";
+export declare const SchemaVersionCurrent = "4";
+export declare const ProjectCreatedTimestamp = "ProjectCreated";
+export declare const ProjectLastModifiedTimestamp = "ProjectLastModified";
+export declare const ProjectMetaKey = "ProjectMeta";
+export declare const ProjectStructureKey = "ProjectStructure";
+export declare const BlockArgsAuthorKeyPrefix = "BlockArgsAuthor/";
+export declare const ProjectStructureAuthorKey = "ProjectStructureAuthor";
+export interface ProjectField {
   blockId: string;
   fieldName: "blockPack" | "blockSettings" | "blockStorage" | "prodArgs" | "currentArgs" | "currentPrerunArgs" | "prodChainCtx" | "prodCtx" | "prodUiCtx" | "prodOutput" | "prodCtxPrevious" | "prodUiCtxPrevious" | "prodOutputPrevious" | "stagingCtx" | "stagingUiCtx" | "stagingOutput" | "stagingCtxPrevious" | "stagingUiCtxPrevious" | "stagingOutputPrevious";
 }
 //#endregion
-export { BlockArgsAuthorKeyPrefix, ProjectCreatedTimestamp, ProjectField, type ProjectId$1 as ProjectId, ProjectLastModifiedTimestamp, ProjectListEntry$1 as ProjectListEntry, ProjectMetaKey, ProjectResourceType, ProjectStructureAuthorKey, ProjectStructureKey, SchemaVersionCurrent, SchemaVersionKey };
+export { type ProjectId$1 as ProjectId, ProjectListEntry$1 as ProjectListEntry };
 //# sourceMappingURL=project_model.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"project_model.d.ts","names":[],"sources":["../../src/model/project_model.ts"],"mappings":";;;;;UAUiB,kBAAA,SAAyB,IAAA,CAAK,gBAAA;EAA9B;EAEf,EAAA,EAAI,WAAA;AAAA;AAAA,cA+DO,mBAAA,EAAqB,YAAoD;AAAA,cAEzE,gBAAA;AAAA,cAGA,oBAAA;AAAA,cAEA,uBAAA;AAAA,cACA,4BAAA;AAAA,cACA,cAAA;AAAA,cACA,mBAAA;AAAA,cAGA,wBAAA;AAAA,cAOA,yBAAA;AAAA,UAQI,YAAA;EACf,OAAA;EACA,SAAS;AAAA"}
+{"version":3,"file":"project_model.d.ts","names":[],"sources":["../../src/model/project_model.ts"],"mappings":";;;;;UAUiB,2BAAyB,KAAK;;EAE7C,IAAI;;qBA+DO,qBAAqB;qBAErB;qBAGA;qBAEA;qBACA;qBACA;qBACA;qBAGA;qBAOA;iBAQI;EACf;EACA"}

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"}