@milaboratories/pl-middle-layer 1.67.5 → 1.68.0

package/dist/block_registry/registry-v2-provider.d.ts

@@ -1,13 +1,11 @@
 import { Dispatcher } from "undici";
 import { RegistryV2Reader } from "@platforma-sdk/block-tools";
-
 //#region src/block_registry/registry-v2-provider.d.ts
-declare class V2RegistryProvider {
+export declare class V2RegistryProvider {
   private readonly http;
   private readonly registries;
   constructor(http: Dispatcher);
   getRegistry(url: string): RegistryV2Reader;
 }
 //#endregion
-export { V2RegistryProvider };
 //# sourceMappingURL=registry-v2-provider.d.ts.map

package/dist/block_registry/registry-v2-provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry-v2-provider.d.ts","names":[],"sources":["../../src/block_registry/registry-v2-provider.ts"],"mappings":";;;;cAGa,kBAAA;EAAA,iBAGkB,IAAA;EAAA,iBAFZ,UAAA;cAEY,IAAA,EAAM,UAAA;EAE5B,WAAA,CAAY,GAAA,WAAc,gBAAgB;AAAA"}
+{"version":3,"file":"registry-v2-provider.d.ts","names":[],"sources":["../../src/block_registry/registry-v2-provider.ts"],"mappings":";;;qBAGa;mBAGkB;mBAFZ;EAEjB,YAA6B,MAAM;EAE5B,YAAY,cAAc"}

package/dist/block_registry/registry.d.ts

@@ -3,17 +3,16 @@ import { BlockPackFromRegistryV2, BlockPackId, BlockPackListing, RegistryEntry,
 import { Dispatcher } from "undici";
 import { BlockPackDescriptionAbsolute } from "@platforma-sdk/block-tools";
 import { BlockKindReference } from "@milaboratories/pl-model-common";
-
 //#region src/block_registry/registry.d.ts
-declare function getDevV1PacketMtime(devPath: string): Promise<string>;
-declare function getDevV2PacketMtime(description: BlockPackDescriptionAbsolute): Promise<string>;
+export declare function getDevV1PacketMtime(devPath: string): Promise<string>;
+export declare function getDevV2PacketMtime(description: BlockPackDescriptionAbsolute): Promise<string>;
 /** Mtime for a `from-pack-v2` locator: prefer the manifest `timestamp`, else
  * stat the `ui.tgz` archive. Must be called identically by `block_pack.ts`
  * prepare (which bakes the result into the spec) and the update watcher (which
  * recomputes it to diff against the stored value) — divergence makes the block
  * flap perpetually "update available". */
-declare function getFromPackV2Mtime(packDir: string, uiTgzPath: string): Promise<string>;
-declare class BlockPackRegistry {
+export declare function getFromPackV2Mtime(packDir: string, uiTgzPath: string): Promise<string>;
+export declare class BlockPackRegistry {
   private readonly v2Provider;
   private readonly registries;
   private readonly http?;
@@ -30,12 +29,9 @@ declare class BlockPackRegistry {
    * delegate to the reader's pure-core-backed `resolveKind`. All version-math
    * lives in `@platforma-sdk/block-tools` (no backend involvement).
    */
-  resolveKind(registryId: string, ref: BlockKindReference, {
-    allowUnstable
-  }: {
+  resolveKind(registryId: string, ref: BlockKindReference, { allowUnstable }: {
     allowUnstable: boolean;
   }): Promise<BlockPackFromRegistryV2>;
 }
 //#endregion
-export { BlockPackRegistry, getDevV1PacketMtime, getDevV2PacketMtime, getFromPackV2Mtime };
 //# sourceMappingURL=registry.d.ts.map

package/dist/block_registry/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","names":[],"sources":["../../src/block_registry/registry.ts"],"mappings":";;;;;;;iBA8CsB,mBAAA,CAAoB,OAAA,WAAkB,OAAO;AAAA,iBAW7C,mBAAA,CACpB,WAAA,EAAa,4BAAA,GACZ,OAAO;AAbV;;;;AAAmE;AAAnE,iBA0BsB,kBAAA,CAAmB,OAAA,UAAiB,SAAA,WAAoB,OAAO;AAAA,cAcxE,iBAAA;EAAA,iBAEQ,UAAA;EAAA,iBACA,UAAA;EAAA,iBACA,IAAA;cAFA,UAAA,EAAY,kBAAA,EACZ,UAAA,EAAY,aAAA,IACZ,IAAA,GAAO,UAAA;EAAA,QAGZ,kBAAA;EA4LD,cAAA,CAAe,OAAA;IAAY,MAAA,GAAS,WAAA;EAAA,IAAgB,OAAA,CAAQ,gBAAA;EAU5D,WAAA,CACX,UAAA,UACA,OAAA,EAAS,WAAA,EACT,OAAA,WACC,OAAA,CAAQ,uBAAA;;;;;;;AA/NwE;EAiPtE,WAAA,CACX,UAAA,UACA,GAAA,EAAK,kBAAA;IACH;EAAA;IAAmB,aAAA;EAAA,IACpB,OAAA,CAAQ,uBAAA;AAAA"}
+{"version":3,"file":"registry.d.ts","names":[],"sources":["../../src/block_registry/registry.ts"],"mappings":";;;;;;wBA8CsB,oBAAoB,kBAAkB;wBAWtC,oBACpB,aAAa,+BACZ;;;;;;wBAamB,mBAAmB,iBAAiB,oBAAoB;qBAcjE;mBAEQ;mBACA;mBACA;EAHnB,YACmB,YAAY,oBACZ,YAAY,iBACZ,OAAO;UAGZ;EA4LD,eAAe;IAAY,SAAS;MAAgB,QAAQ;EAU5D,YACX,oBACA,SAAS,aACT,kBACC,QAAQ;;;;;;;;EAkBE,YACX,oBACA,KAAK,sBACH;IAAmB;MACpB,QAAQ"}

package/dist/block_registry/template_provider.d.ts

@@ -2,7 +2,6 @@ import { BlockPackProvider } from "../model/template_resolve.js";
 import { BlockPackFromRegistryV2, BlockPackId, RegistryEntry, SingleBlockPackOverview } from "@milaboratories/pl-model-middle-layer";
 import { MiLogger } from "@milaboratories/ts-helpers";
 import { BlockKindReference } from "@milaboratories/pl-model-common";
-
 //#region src/block_registry/template_provider.d.ts
 /**
  * The part of {@link BlockPackRegistry} a template's provider uses.
@@ -11,7 +10,7 @@ import { BlockKindReference } from "@milaboratories/pl-model-common";
  * configured environment — and so it is obvious that these two calls are the entire
  * dependency.
  */
-type KindAwareRegistry = {
+export type KindAwareRegistry = {
   resolveKind: (registryId: string, ref: BlockKindReference, options: {
     allowUnstable: boolean;
   }) => Promise<BlockPackFromRegistryV2>;
@@ -32,7 +31,7 @@ type KindAwareRegistry = {
  * registries — with the search stopping at the first hit, the earlier registry is
  * simply the answer.
  */
-declare function kindCapableRegistryIds(entries: readonly RegistryEntry[]): string[];
+export declare function kindCapableRegistryIds(entries: readonly RegistryEntry[]): string[];
 /**
  * A {@link BlockPackProvider} over the configured block registries.
  *
@@ -52,11 +51,10 @@ declare function kindCapableRegistryIds(entries: readonly RegistryEntry[]): stri
  *   fallback to the next registry has to swallow the reason; this is the only place it
  *   survives
  */
-declare function templateBlockPackProvider(deps: {
+export declare function templateBlockPackProvider(deps: {
   readonly registry: KindAwareRegistry;
   readonly registryIds: readonly string[];
   readonly logger: MiLogger;
 }): BlockPackProvider;
 //#endregion
-export { KindAwareRegistry, kindCapableRegistryIds, templateBlockPackProvider };
 //# sourceMappingURL=template_provider.d.ts.map

package/dist/block_registry/template_provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template_provider.d.ts","names":[],"sources":["../../src/block_registry/template_provider.ts"],"mappings":";;;;;;;;AAqBA;;;;;KAAY,iBAAA;EACV,WAAA,GACE,UAAA,UACA,GAAA,EAAK,kBAAA,EACL,OAAA;IAAW,aAAA;EAAA,MACR,OAAA,CAAQ,uBAAA;EACb,WAAA,GACE,UAAA,UACA,OAAA,EAAS,WAAA,EACT,OAAA,aACG,OAAA,CAAQ,uBAAA;AAAA;;;;;;;;;;;;;;;;iBAkBC,sBAAA,CAAuB,OAAiC,WAAf,aAAa;AAlBhC;AAkBtC;;;;AAAwE;AAuBxE;;;;;;;;;;;;;AAzCsC,iBAyCtB,yBAAA,CAA0B,IAAA;EAAA,SAC/B,QAAA,EAAU,iBAAA;EAAA,SACV,WAAA;EAAA,SACA,MAAA,EAAQ,QAAA;AAAA,IACf,iBAAA"}
+{"version":3,"file":"template_provider.d.ts","names":[],"sources":["../../src/block_registry/template_provider.ts"],"mappings":";;;;;;;;;;;;YAqBY;EACV,cACE,oBACA,KAAK,oBACL;IAAW;QACR,QAAQ;EACb,cACE,oBACA,SAAS,aACT,oBACG,QAAQ;;;;;;;;;;;;;;;;;wBAkBC,uBAAuB,kBAAkB;;;;;;;;;;;;;;;;;;;;wBAuBzC,0BAA0B;WAC/B,UAAU;WACV;WACA,QAAQ;IACf"}

package/dist/block_registry/watcher.d.ts

@@ -3,21 +3,20 @@ import { BlockPackSpec, BlockSettings, UpdateSuggestions } from "@milaboratories
 import { Dispatcher } from "undici";
 import { MiLogger } from "@milaboratories/ts-helpers";
 import { PollComputablePool, PollPoolOps } from "@milaboratories/computable";
-
 //#region src/block_registry/watcher.d.ts
-type BlockUpdateWatcherOps = Partial<PollPoolOps> & {
+export type BlockUpdateWatcherOps = Partial<PollPoolOps> & {
   readonly http?: Dispatcher;
   readonly preferredUpdateChannel?: string;
 };
-type CheckForUpdateRequest = {
+export type CheckForUpdateRequest = {
   currentSpec: BlockPackSpec;
   settings: BlockSettings;
 };
-type CheckForUpdateResponse = {
+export type CheckForUpdateResponse = {
   suggestions: UpdateSuggestions;
   mainSuggestion?: BlockPackSpec;
 };
-declare class BlockUpdateWatcher extends PollComputablePool<CheckForUpdateRequest, CheckForUpdateResponse> {
+export declare class BlockUpdateWatcher extends PollComputablePool<CheckForUpdateRequest, CheckForUpdateResponse> {
   private readonly registryProvider;
   private readonly http?;
   private readonly preferredUpdateChannel?;
@@ -27,5 +26,4 @@ declare class BlockUpdateWatcher extends PollComputablePool<CheckForUpdateReques
   protected resultsEqual(res1: CheckForUpdateResponse, res2: CheckForUpdateResponse): boolean;
 }
 //#endregion
-export { BlockUpdateWatcher, BlockUpdateWatcherOps, CheckForUpdateRequest, CheckForUpdateResponse };
 //# sourceMappingURL=watcher.d.ts.map

package/dist/block_registry/watcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watcher.d.ts","names":[],"sources":["../../src/block_registry/watcher.ts"],"mappings":";;;;;;;KA6BY,qBAAA,GAAwB,OAAA,CAAQ,WAAA;EAAA,SACjC,IAAA,GAAO,UAAA;EAAA,SACP,sBAAA;AAAA;AAAA,KAKC,qBAAA;EACV,WAAA,EAAa,aAAA;EACb,QAAA,EAAU,aAAa;AAAA;AAAA,KAGb,sBAAA;EACV,WAAA,EAAa,iBAAA;EACb,cAAA,GAAiB,aAAa;AAAA;AAAA,cAGnB,kBAAA,SAA2B,kBAAA,CACtC,qBAAA,EACA,sBAAA;EAAA,iBAMmB,gBAAA;EAAA,iBAJF,IAAA;EAAA,iBACA,sBAAA;cAGE,gBAAA,EAAkB,kBAAA,EACnC,MAAA,EAAQ,QAAA,EACR,GAAA,GAAK,qBAAA;EAAA,UAOG,MAAA,CAAO,GAAA,EAAK,qBAAA;EAAA,UAeN,SAAA,CAAU,GAAA,EAAK,qBAAA,GAAwB,OAAA,CAAQ,sBAAA;EAAA,UAgIrD,YAAA,CAAa,IAAA,EAAM,sBAAA,EAAwB,IAAA,EAAM,sBAAA;AAAA"}
+{"version":3,"file":"watcher.d.ts","names":[],"sources":["../../src/block_registry/watcher.ts"],"mappings":";;;;;;YA6BY,wBAAwB,QAAQ;WACjC,OAAO;WACP;;YAKC;EACV,aAAa;EACb,UAAU;;YAGA;EACV,aAAa;EACb,iBAAiB;;qBAGN,2BAA2B,mBACtC,uBACA;mBAMmB;mBAJF;mBACA;EAEjB,YACmB,kBAAkB,oBACnC,QAAQ,UACR,MAAK;YAOG,OAAO,KAAK;YAeN,UAAU,KAAK,wBAAwB,QAAQ;YAgIrD,aAAa,MAAM,wBAAwB,MAAM"}

package/dist/block_registry/well_known_registries.d.ts

@@ -1,9 +1,7 @@
 import { RegistrySpec } from "@milaboratories/pl-model-middle-layer";
-
 //#region src/block_registry/well_known_registries.d.ts
-declare const CentralBlockRegistry: RegistrySpec;
-declare const V1CentralRegistry: RegistrySpec;
-declare const V1CentralDevSnapshotRegistry: RegistrySpec;
+export declare const CentralBlockRegistry: RegistrySpec;
+export declare const V1CentralRegistry: RegistrySpec;
+export declare const V1CentralDevSnapshotRegistry: RegistrySpec;
 //#endregion
-export { CentralBlockRegistry, V1CentralDevSnapshotRegistry, V1CentralRegistry };
 //# sourceMappingURL=well_known_registries.d.ts.map

package/dist/block_registry/well_known_registries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"well_known_registries.d.ts","names":[],"sources":["../../src/block_registry/well_known_registries.ts"],"mappings":";;;cAEa,oBAAA,EAAsB,YAGlC;AAAA,cAEY,iBAAA,EAAmB,YAG/B;AAAA,cAEY,4BAAA,EAA8B,YAG1C"}
+{"version":3,"file":"well_known_registries.d.ts","names":[],"sources":["../../src/block_registry/well_known_registries.ts"],"mappings":";;qBAEa,sBAAsB;qBAKtB,mBAAmB;qBAKnB,8BAA8B"}

package/dist/index.d.ts

@@ -4,17 +4,21 @@ import { CentralBlockRegistry, V1CentralDevSnapshotRegistry, V1CentralRegistry }
 import { AppliedEntry, TemplateApplyProblem, TemplateApplyReport, TemplateEntryRejected } from "./model/template_apply.js";
 import { BlockPackProvider, ExactResolution, KindResolution, ResolvedEntry, TemplateResolveOutcome, parseBlockPackName, resolveTemplateEntries } from "./model/template_resolve.js";
 import { KindAwareRegistry, kindCapableRegistryIds, templateBlockPackProvider } from "./block_registry/template_provider.js";
+import "./block_registry/index.js";
 import { BlockArgsAuthorKeyPrefix, ProjectCreatedTimestamp, ProjectField, ProjectId, ProjectLastModifiedTimestamp, ProjectListEntry, ProjectMetaKey, ProjectResourceType, ProjectStructureAuthorKey, ProjectStructureKey, SchemaVersionCurrent, SchemaVersionKey } from "./model/project_model.js";
 import { AcceptanceFieldPrefix, EnvelopeAcceptance, EnvelopeData, EnvelopeMode, EnvelopeProject, ProjectChangeAction, ProjectFieldUuid, ShareId, ShareProjectsOptions, SharedEnvelopeResourceType, SharingDecision, SharingOutboxField, SharingOutboxResourceType, SharingStateField, SharingStateResourceType, acceptanceField, acceptanceFieldLogin, asShareId, canGrantToEveryone, canImpersonate, decisionField, decodeEnvelopeData, isAcceptanceField, newShareId } from "./model/sharing_model.js";
 import { OutgoingShare, PendingShare } from "./middle_layer/sharing_list.js";
 import { CachedTemplate, ExplicitTemplate, PreparedTemplate, TemplateFromFile, TemplateFromRegistry, TemplateSpecAny, TemplateSpecPrepared } from "./model/template_spec.js";
 import { BlockPackExplicit, BlockPackSpecAny, BlockPackSpecPrepared, FrontendFromFolder, FrontendFromFolderData, FrontendFromFolderResourceType, FrontendFromLocalTgz, FrontendFromLocalTgzData, FrontendFromLocalTgzResourceType, FrontendFromUrl, FrontendFromUrlData, FrontendFromUrlResourceType, FrontendSpec } from "./model/block_pack_spec.js";
 import { TemplateParseOutcome, parseProjectTemplateV1Yaml } from "./model/template_parser.js";
+import "./model/index.js";
 import { Project } from "./middle_layer/project.js";
-import { DefaultDriverKitOpsPaths, DefaultDriverKitOpsSettings, DefaultMiddleLayerOpsPaths, DefaultMiddleLayerOpsSettings, DriverKitOps, DriverKitOpsConstructor, DriverKitOpsPaths, DriverKitOpsSettings, MiddleLayerDebugOptions, MiddleLayerOps, MiddleLayerOpsConstructor, MiddleLayerOpsPaths, MiddleLayerOpsSettings } from "./middle_layer/ops.js";
+import { DefaultDriverKitOpsPaths, DefaultDriverKitOpsSettings, DefaultMiddleLayerOpsPaths, DefaultMiddleLayerOpsSettings, DriverKitOps, DriverKitOpsConstructor, DriverKitOpsPaths, DriverKitOpsSettings, MiddleLayerDebugOptions, MiddleLayerOps, MiddleLayerOpsConstructor, MiddleLayerOpsPaths, MiddleLayerOpsSettings, TreeSnapshotOps } from "./middle_layer/ops.js";
 import { MiddleLayerDriverKit, initDriverKit } from "./middle_layer/driver_kit.js";
+import { TreeSnapshotMiss, TreeSnapshotStat } from "./middle_layer/tree_snapshot_store.js";
 import { MiddleLayer } from "./middle_layer/middle_layer.js";
 import { ProjectsField } from "./middle_layer/project_list.js";
+import "./middle_layer/index.js";
 import { CheckNetworkOpts, checkNetwork, initNetworkCheck } from "./network_check/network_check.js";
 import { TengoTemplateGet, TengoTemplateGetRegistry, TengoTemplateGetTemplate, TengoTemplateGetTemplateURI, TengoTemplatePack, TengoTemplatePackConvert, TengoTemplatePackConvertTemplate, TengoTemplatePackConvertTemplatePack, loadTemplate, prepareTemplateSpec } from "./mutator/template/template_loading.js";
 import { ACCESS_COUNT_KEY, ACCESS_KEY_PREFIX, GC_ACCESS_THRESHOLD, GC_MAX_ENTRIES, TemplateCacheFieldName, TemplateCacheStat, TemplateCacheType, cacheBlockPackTemplate, dropTemplateCache, flattenTemplateTree, getOrCreateTemplateCache, invalidateTemplateCacheId, loadTemplateCached, runGc } from "./mutator/template/template_cache.js";
@@ -28,4 +32,4 @@ export * from "@platforma-sdk/model";
 export * from "@milaboratories/pl-model-middle-layer";
 export * from "@milaboratories/pl-deployments";
 export * from "@milaboratories/pl-client";
-export { ACCESS_COUNT_KEY, ACCESS_KEY_PREFIX, AcceptanceFieldPrefix, type AppliedEntry, BlockArgsAuthorKeyPrefix, BlockPackExplicit, type BlockPackProvider, BlockPackRegistry, BlockPackSpecAny, BlockPackSpecPrepared, CachedTemplate, CentralBlockRegistry, CheckNetworkOpts, DefaultDriverKitOpsPaths, DefaultDriverKitOpsSettings, DefaultMiddleLayerOpsPaths, DefaultMiddleLayerOpsSettings, DriverKitOps, DriverKitOpsConstructor, DriverKitOpsPaths, DriverKitOpsSettings, EnvelopeAcceptance, EnvelopeData, EnvelopeMode, EnvelopeProject, type ExactResolution, ExplicitTemplate, type FieldType, FrontendFromFolder, FrontendFromFolderData, FrontendFromFolderResourceType, FrontendFromLocalTgz, FrontendFromLocalTgzData, FrontendFromLocalTgzResourceType, FrontendFromUrl, FrontendFromUrlData, FrontendFromUrlResourceType, FrontendSpec, GC_ACCESS_THRESHOLD, GC_MAX_ENTRIES, type InternalLsDriver, KindAwareRegistry, type KindResolution, MiddleLayer, MiddleLayerDebugOptions, MiddleLayerDriverKit, MiddleLayerOps, MiddleLayerOpsConstructor, MiddleLayerOpsPaths, MiddleLayerOpsSettings, type OutgoingShare, type PendingShare, PreparedTemplate, Project, ProjectChangeAction, ProjectCreatedTimestamp, type ProjectField, ProjectFieldUuid, type ProjectId, ProjectLastModifiedTimestamp, type ProjectListEntry, ProjectMetaKey, ProjectResourceType, ProjectStructureAuthorKey, ProjectStructureKey, ProjectsField, type ResolvedEntry, type ResourceType, SchemaVersionCurrent, SchemaVersionKey, ShareId, ShareProjectsOptions, SharedEnvelopeResourceType, SharingDecision, SharingOutboxField, SharingOutboxResourceType, SharingStateField, SharingStateResourceType, type TemplateApplyProblem, type TemplateApplyReport, TemplateCacheFieldName, TemplateCacheStat, TemplateCacheType, TemplateEntryRejected, TemplateFromFile, TemplateFromRegistry, type TemplateParseOutcome, type TemplateResolveOutcome, TemplateSpecAny, TemplateSpecPrepared, TengoTemplateGet, TengoTemplateGetRegistry, TengoTemplateGetTemplate, TengoTemplateGetTemplateURI, TengoTemplatePack, TengoTemplatePackConvert, TengoTemplatePackConvertTemplate, TengoTemplatePackConvertTemplatePack, V1CentralDevSnapshotRegistry, V1CentralRegistry, V2RegistryProvider, acceptanceField, acceptanceFieldLogin, asShareId, cacheBlockPackTemplate, canGrantToEveryone, canImpersonate, checkNetwork, createRenderTemplate, decisionField, decodeEnvelopeData, deriveGlobalPObjectId, deriveLocalPObjectId, dropTemplateCache, duplicateProject, flattenTemplateTree, getDevV1PacketMtime, getDevV2PacketMtime, getFromPackV2Mtime, getOrCreateTemplateCache, initDriverKit, initNetworkCheck, invalidateTemplateCacheId, isAcceptanceField, kindCapableRegistryIds, loadTemplate, loadTemplateCached, newShareId, parseBlockPackName, parseFinalPObjectCollection, parseProjectTemplateV1Yaml, prepareTemplateSpec, resolveTemplateEntries, runGc, templateBlockPackProvider };
+export { ACCESS_COUNT_KEY, ACCESS_KEY_PREFIX, AcceptanceFieldPrefix, type AppliedEntry, BlockArgsAuthorKeyPrefix, BlockPackExplicit, type BlockPackProvider, BlockPackRegistry, BlockPackSpecAny, BlockPackSpecPrepared, CachedTemplate, CentralBlockRegistry, CheckNetworkOpts, DefaultDriverKitOpsPaths, DefaultDriverKitOpsSettings, DefaultMiddleLayerOpsPaths, DefaultMiddleLayerOpsSettings, DriverKitOps, DriverKitOpsConstructor, DriverKitOpsPaths, DriverKitOpsSettings, EnvelopeAcceptance, EnvelopeData, EnvelopeMode, EnvelopeProject, type ExactResolution, ExplicitTemplate, type FieldType, FrontendFromFolder, FrontendFromFolderData, FrontendFromFolderResourceType, FrontendFromLocalTgz, FrontendFromLocalTgzData, FrontendFromLocalTgzResourceType, FrontendFromUrl, FrontendFromUrlData, FrontendFromUrlResourceType, FrontendSpec, GC_ACCESS_THRESHOLD, GC_MAX_ENTRIES, type InternalLsDriver, KindAwareRegistry, type KindResolution, MiddleLayer, MiddleLayerDebugOptions, MiddleLayerDriverKit, MiddleLayerOps, MiddleLayerOpsConstructor, MiddleLayerOpsPaths, MiddleLayerOpsSettings, type OutgoingShare, type PendingShare, PreparedTemplate, Project, ProjectChangeAction, ProjectCreatedTimestamp, type ProjectField, ProjectFieldUuid, type ProjectId, ProjectLastModifiedTimestamp, type ProjectListEntry, ProjectMetaKey, ProjectResourceType, ProjectStructureAuthorKey, ProjectStructureKey, ProjectsField, type ResolvedEntry, type ResourceType, SchemaVersionCurrent, SchemaVersionKey, ShareId, ShareProjectsOptions, SharedEnvelopeResourceType, SharingDecision, SharingOutboxField, SharingOutboxResourceType, SharingStateField, SharingStateResourceType, type TemplateApplyProblem, type TemplateApplyReport, TemplateCacheFieldName, TemplateCacheStat, TemplateCacheType, TemplateEntryRejected, TemplateFromFile, TemplateFromRegistry, type TemplateParseOutcome, type TemplateResolveOutcome, TemplateSpecAny, TemplateSpecPrepared, TengoTemplateGet, TengoTemplateGetRegistry, TengoTemplateGetTemplate, TengoTemplateGetTemplateURI, TengoTemplatePack, TengoTemplatePackConvert, TengoTemplatePackConvertTemplate, TengoTemplatePackConvertTemplatePack, type TreeSnapshotMiss, TreeSnapshotOps, type TreeSnapshotStat, V1CentralDevSnapshotRegistry, V1CentralRegistry, V2RegistryProvider, acceptanceField, acceptanceFieldLogin, asShareId, cacheBlockPackTemplate, canGrantToEveryone, canImpersonate, checkNetwork, createRenderTemplate, decisionField, decodeEnvelopeData, deriveGlobalPObjectId, deriveLocalPObjectId, dropTemplateCache, duplicateProject, flattenTemplateTree, getDevV1PacketMtime, getDevV2PacketMtime, getFromPackV2Mtime, getOrCreateTemplateCache, initDriverKit, initNetworkCheck, invalidateTemplateCacheId, isAcceptanceField, kindCapableRegistryIds, loadTemplate, loadTemplateCached, newShareId, parseBlockPackName, parseFinalPObjectCollection, parseProjectTemplateV1Yaml, prepareTemplateSpec, resolveTemplateEntries, runGc, templateBlockPackProvider };

package/dist/middle_layer/build_stamp.cjs

@@ -0,0 +1,34 @@
+//#region src/middle_layer/build_stamp.ts
+function injectedStamp() {
+	try {
+		return "48a74953f8cd-dirty-1787671552027";
+	} catch {
+		return;
+	}
+}
+/**
+* Identifies the build of this package, and through it the rules that shape what a persisted
+* tree mirror contains: the pruning function, the field filter and the traversal stop rules,
+* all of which live in this package. (The finality predicate comes from pl-client and is NOT
+* covered, which is harmless: finality is recomputed on restore, so it is the one rule that
+* cannot poison a stored file.)
+*
+* Used as a cache-key component, so a change to those rules invalidates every snapshot, costing
+* one cold open. Each built artifact bakes in one stamp, so reopens stay warm across restarts
+* of an installed version. A build from a dirty worktree includes the build time, so editing
+* those rules locally can never hit a snapshot written under the old ones. In practice release
+* builds are dirty too, because CI writes version bumps into the worktree before building; that
+* costs nothing, since the stamp only has to be stable within an artifact.
+*
+* With no build at all (sources mode) the value is a constant. That deliberately trades away
+* the dirty-worktree guarantee: it means someone running from sources exercises the restore
+* path at all, rather than every snapshot being a guaranteed miss for the one audience most
+* likely to find its defects. The exposure it reintroduces, editing pruning rules from sources
+* and hitting a mirror written under the old ones, is the local-development gap the design
+* already accepts, and `treeSnapshots: false` or deleting the directory clears it.
+*/
+const ML_BUILD_STAMP = injectedStamp() ?? "sources";
+//#endregion
+exports.ML_BUILD_STAMP = ML_BUILD_STAMP;
+
+//# sourceMappingURL=build_stamp.cjs.map

package/dist/middle_layer/build_stamp.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_stamp.cjs","names":[],"sources":["../../src/middle_layer/build_stamp.ts"],"sourcesContent":["/** Injected by rolldown at build time, see `build.node.config.js`. Absent when the package is\n *  consumed straight from sources (`USE_SOURCES=1`), because no build step runs then. */\ndeclare const __PL_ML_BUILD_STAMP__: string | undefined;\n\nfunction injectedStamp(): string | undefined {\n  try {\n    // Read inside a try: with no build step the identifier is an undeclared global, and\n    // reading it throws a ReferenceError rather than yielding undefined.\n    return __PL_ML_BUILD_STAMP__;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Identifies the build of this package, and through it the rules that shape what a persisted\n * tree mirror contains: the pruning function, the field filter and the traversal stop rules,\n * all of which live in this package. (The finality predicate comes from pl-client and is NOT\n * covered, which is harmless: finality is recomputed on restore, so it is the one rule that\n * cannot poison a stored file.)\n *\n * Used as a cache-key component, so a change to those rules invalidates every snapshot, costing\n * one cold open. Each built artifact bakes in one stamp, so reopens stay warm across restarts\n * of an installed version. A build from a dirty worktree includes the build time, so editing\n * those rules locally can never hit a snapshot written under the old ones. In practice release\n * builds are dirty too, because CI writes version bumps into the worktree before building; that\n * costs nothing, since the stamp only has to be stable within an artifact.\n *\n * With no build at all (sources mode) the value is a constant. That deliberately trades away\n * the dirty-worktree guarantee: it means someone running from sources exercises the restore\n * path at all, rather than every snapshot being a guaranteed miss for the one audience most\n * likely to find its defects. The exposure it reintroduces, editing pruning rules from sources\n * and hitting a mirror written under the old ones, is the local-development gap the design\n * already accepts, and `treeSnapshots: false` or deleting the directory clears it.\n */\nexport const ML_BUILD_STAMP: string = injectedStamp() ?? \"sources\";\n"],"mappings":";AAIA,SAAS,gBAAoC;CAC3C,IAAI;EAGF,OAAA;CACF,QAAQ;EACN;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,iBAAyB,cAAc,KAAK"}

package/dist/middle_layer/build_stamp.js

@@ -0,0 +1,34 @@
+//#region src/middle_layer/build_stamp.ts
+function injectedStamp() {
+	try {
+		return "48a74953f8cd-dirty-1787671551997";
+	} catch {
+		return;
+	}
+}
+/**
+* Identifies the build of this package, and through it the rules that shape what a persisted
+* tree mirror contains: the pruning function, the field filter and the traversal stop rules,
+* all of which live in this package. (The finality predicate comes from pl-client and is NOT
+* covered, which is harmless: finality is recomputed on restore, so it is the one rule that
+* cannot poison a stored file.)
+*
+* Used as a cache-key component, so a change to those rules invalidates every snapshot, costing
+* one cold open. Each built artifact bakes in one stamp, so reopens stay warm across restarts
+* of an installed version. A build from a dirty worktree includes the build time, so editing
+* those rules locally can never hit a snapshot written under the old ones. In practice release
+* builds are dirty too, because CI writes version bumps into the worktree before building; that
+* costs nothing, since the stamp only has to be stable within an artifact.
+*
+* With no build at all (sources mode) the value is a constant. That deliberately trades away
+* the dirty-worktree guarantee: it means someone running from sources exercises the restore
+* path at all, rather than every snapshot being a guaranteed miss for the one audience most
+* likely to find its defects. The exposure it reintroduces, editing pruning rules from sources
+* and hitting a mirror written under the old ones, is the local-development gap the design
+* already accepts, and `treeSnapshots: false` or deleting the directory clears it.
+*/
+const ML_BUILD_STAMP = injectedStamp() ?? "sources";
+//#endregion
+export { ML_BUILD_STAMP };
+
+//# sourceMappingURL=build_stamp.js.map

package/dist/middle_layer/build_stamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_stamp.js","names":[],"sources":["../../src/middle_layer/build_stamp.ts"],"sourcesContent":["/** Injected by rolldown at build time, see `build.node.config.js`. Absent when the package is\n *  consumed straight from sources (`USE_SOURCES=1`), because no build step runs then. */\ndeclare const __PL_ML_BUILD_STAMP__: string | undefined;\n\nfunction injectedStamp(): string | undefined {\n  try {\n    // Read inside a try: with no build step the identifier is an undeclared global, and\n    // reading it throws a ReferenceError rather than yielding undefined.\n    return __PL_ML_BUILD_STAMP__;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Identifies the build of this package, and through it the rules that shape what a persisted\n * tree mirror contains: the pruning function, the field filter and the traversal stop rules,\n * all of which live in this package. (The finality predicate comes from pl-client and is NOT\n * covered, which is harmless: finality is recomputed on restore, so it is the one rule that\n * cannot poison a stored file.)\n *\n * Used as a cache-key component, so a change to those rules invalidates every snapshot, costing\n * one cold open. Each built artifact bakes in one stamp, so reopens stay warm across restarts\n * of an installed version. A build from a dirty worktree includes the build time, so editing\n * those rules locally can never hit a snapshot written under the old ones. In practice release\n * builds are dirty too, because CI writes version bumps into the worktree before building; that\n * costs nothing, since the stamp only has to be stable within an artifact.\n *\n * With no build at all (sources mode) the value is a constant. That deliberately trades away\n * the dirty-worktree guarantee: it means someone running from sources exercises the restore\n * path at all, rather than every snapshot being a guaranteed miss for the one audience most\n * likely to find its defects. The exposure it reintroduces, editing pruning rules from sources\n * and hitting a mirror written under the old ones, is the local-development gap the design\n * already accepts, and `treeSnapshots: false` or deleting the directory clears it.\n */\nexport const ML_BUILD_STAMP: string = injectedStamp() ?? \"sources\";\n"],"mappings":";AAIA,SAAS,gBAAoC;CAC3C,IAAI;EAGF,OAAA;CACF,QAAQ;EACN;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,iBAAyB,cAAc,KAAK"}

package/dist/middle_layer/driver_kit.d.ts

@@ -1,10 +1,10 @@
 import { InternalPFrameDriver } from "../pool/driver.js";
+import "../pool/index.js";
 import { DriverKitOpsConstructor } from "./ops.js";
 import { Signer } from "@milaboratories/ts-helpers";
 import * as Sdk from "@milaboratories/pl-model-common";
 import { PlClient } from "@milaboratories/pl-client";
 import { DownloadBlobToURLDriver, DownloadDriver, DownloadUrlDriver, InternalLsDriver, LogsDriver, UploadDriver } from "@milaboratories/pl-drivers";
-
 //#region src/middle_layer/driver_kit.d.ts
 /**
  * Drivers offered by the middle-layer for internal consumers,
@@ -13,7 +13,7 @@ import { DownloadBlobToURLDriver, DownloadDriver, DownloadUrlDriver, InternalLsD
  * This intertface is basically a version of the DriverKit from
  * UI SDK with extended API.
  * */
-interface MiddleLayerDriverKit extends Sdk.DriverKit, AsyncDisposable {
+export interface MiddleLayerDriverKit extends Sdk.DriverKit, AsyncDisposable {
   /** Dispose the driver kit and all its resources. */
   dispose(): Promise<void>;
   readonly blobDriver: DownloadDriver;
@@ -33,7 +33,6 @@ interface MiddleLayerDriverKit extends Sdk.DriverKit, AsyncDisposable {
    * */
   readonly uploadDriver: UploadDriver;
 }
-declare function initDriverKit(pl: PlClient, workdir: string, frontendDownloadPath: string, _ops: DriverKitOpsConstructor): Promise<MiddleLayerDriverKit>;
+export declare function initDriverKit(pl: PlClient, workdir: string, frontendDownloadPath: string, _ops: DriverKitOpsConstructor): Promise<MiddleLayerDriverKit>;
 //#endregion
-export { MiddleLayerDriverKit, initDriverKit };
 //# sourceMappingURL=driver_kit.d.ts.map

package/dist/middle_layer/driver_kit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"driver_kit.d.ts","names":[],"sources":["../../src/middle_layer/driver_kit.ts"],"mappings":";;;;;;;;;;AA+BA;;;;;UAAiB,oBAAA,SAA6B,GAAA,CAAI,SAAA,EAAW,eAAA;EASvC;EAPpB,OAAA,IAAW,OAAA;EAAA,SAGF,UAAA,EAAY,cAAA;EAAA,SAEZ,eAAA,EAAiB,uBAAA;EAAA,SAEjB,SAAA,EAAW,UAAA;EAAA,SAEX,QAAA,EAAU,gBAAA;EAAA,SAEV,YAAA,EAAc,oBAAA;EAAA,SAEd,cAAA,EAAgB,iBAAA;EAfiD;;;;EAAA,SAqBjE,MAAA,EAAQ,MAAA;EAnBjB;;;;EAAA,SAyBS,YAAA,EAAc,YAAA;AAAA;AAAA,iBAGH,aAAA,CACpB,EAAA,EAAI,QAAA,EACJ,OAAA,UACA,oBAAA,UACA,IAAA,EAAM,uBAAA,GACL,OAAA,CAAQ,oBAAA"}
+{"version":3,"file":"driver_kit.d.ts","names":[],"sources":["../../src/middle_layer/driver_kit.ts"],"mappings":";;;;;;;;;;;;;;;iBA+BiB,6BAA6B,IAAI,WAAW;;EAE3D,WAAW;WAGF,YAAY;WAEZ,iBAAiB;WAEjB,WAAW;WAEX,UAAU;WAEV,cAAc;WAEd,gBAAgB;;;;;WAMhB,QAAQ;;;;;WAMR,cAAc;;wBAGH,cACpB,IAAI,UACJ,iBACA,8BACA,MAAM,0BACL,QAAQ"}

package/dist/middle_layer/index.d.ts

@@ -1,7 +1,8 @@
 import { OutgoingShare, PendingShare } from "./sharing_list.js";
 import { Project } from "./project.js";
-import { DefaultDriverKitOpsPaths, DefaultDriverKitOpsSettings, DefaultMiddleLayerOpsPaths, DefaultMiddleLayerOpsSettings, DriverKitOps, DriverKitOpsConstructor, DriverKitOpsPaths, DriverKitOpsSettings, MiddleLayerDebugOptions, MiddleLayerOps, MiddleLayerOpsConstructor, MiddleLayerOpsPaths, MiddleLayerOpsSettings } from "./ops.js";
+import { DefaultDriverKitOpsPaths, DefaultDriverKitOpsSettings, DefaultMiddleLayerOpsPaths, DefaultMiddleLayerOpsSettings, DriverKitOps, DriverKitOpsConstructor, DriverKitOpsPaths, DriverKitOpsSettings, MiddleLayerDebugOptions, MiddleLayerOps, MiddleLayerOpsConstructor, MiddleLayerOpsPaths, MiddleLayerOpsSettings, TreeSnapshotOps } from "./ops.js";
 import { MiddleLayerDriverKit, initDriverKit } from "./driver_kit.js";
+import { TreeSnapshotMiss, TreeSnapshotStat } from "./tree_snapshot_store.js";
 import { MiddleLayer } from "./middle_layer.js";
 import { ProjectsField } from "./project_list.js";
-export { DefaultDriverKitOpsPaths, DefaultDriverKitOpsSettings, DefaultMiddleLayerOpsPaths, DefaultMiddleLayerOpsSettings, DriverKitOps, DriverKitOpsConstructor, DriverKitOpsPaths, DriverKitOpsSettings, MiddleLayer, MiddleLayerDebugOptions, MiddleLayerDriverKit, MiddleLayerOps, MiddleLayerOpsConstructor, MiddleLayerOpsPaths, MiddleLayerOpsSettings, type OutgoingShare, type PendingShare, Project, ProjectsField, initDriverKit };
+export { DefaultDriverKitOpsPaths, DefaultDriverKitOpsSettings, DefaultMiddleLayerOpsPaths, DefaultMiddleLayerOpsSettings, DriverKitOps, DriverKitOpsConstructor, DriverKitOpsPaths, DriverKitOpsSettings, MiddleLayer, MiddleLayerDebugOptions, MiddleLayerDriverKit, MiddleLayerOps, MiddleLayerOpsConstructor, MiddleLayerOpsPaths, MiddleLayerOpsSettings, type OutgoingShare, type PendingShare, Project, ProjectsField, type TreeSnapshotMiss, TreeSnapshotOps, type TreeSnapshotStat, initDriverKit };

package/dist/middle_layer/middle_layer.cjs

@@ -18,6 +18,7 @@ const require_watcher = require("../block_registry/watcher.cjs");
 const require_driver_kit = require("./driver_kit.cjs");
 const require_service_factories = require("../service_factories.cjs");
 const require_project_helper = require("../model/project_helper.cjs");
+const require_tree_snapshot_store = require("./tree_snapshot_store.cjs");
 let _platforma_sdk_model = require("@platforma-sdk/model");
 let undici = require("undici");
 let _milaboratories_ts_helpers = require("@milaboratories/ts-helpers");
@@ -28,6 +29,10 @@ let _milaboratories_computable = require("@milaboratories/computable");
 let node_crypto = require("node:crypto");
 let quickjs_emscripten = require("quickjs-emscripten");
 //#region src/middle_layer/middle_layer.ts
+/** How long shutdown waits for close-boundary snapshot writes that are already running. Long
+*  enough for a ten-megabyte encode and write on ordinary storage, short enough that a wedged
+*  filesystem does not hold the quit open. */
+const SNAPSHOT_DRAIN_TIMEOUT_MS = 5e3;
 /**
 * Main access object to work with pl from UI.
 *
@@ -757,6 +762,32 @@ var MiddleLayer = class MiddleLayer {
 		}
 	}
 	openedProjects = /* @__PURE__ */ new Map();
+	/** Snapshot writes started by {@link closeProject} and not yet finished. Held only so
+	*  {@link close} can give them a bounded chance to land. */
+	pendingSnapshotWrites = /* @__PURE__ */ new Set();
+	trackSnapshotWrite(write) {
+		this.pendingSnapshotWrites.add(write);
+		write.finally(() => this.pendingSnapshotWrites.delete(write));
+	}
+	/** Waits for close-boundary snapshot writes that are already running, up to `timeoutMs`.
+	*
+	* This starts no work: quitting still performs no snapshot of its own. It only lets a write
+	* that a project close already began finish, so closing a project and immediately quitting
+	* does not routinely lose it. Bounded, because a wedged filesystem must not hang the quit,
+	* and losing the write costs one cold open rather than any correctness. */
+	async drainSnapshotWrites(timeoutMs) {
+		if (this.pendingSnapshotWrites.size === 0) return;
+		let timer;
+		const expiry = new Promise((resolve) => {
+			timer = setTimeout(resolve, timeoutMs);
+			timer.unref?.();
+		});
+		try {
+			await Promise.race([Promise.allSettled(this.pendingSnapshotWrites), expiry]);
+		} finally {
+			if (timer !== void 0) clearTimeout(timer);
+		}
+	}
 	/** Opens a project, and starts corresponding project maintenance loop. */
 	async openProject(id) {
 		if (this.openedProjects.has(id)) throw new Error(`Project ${id} already opened`);
@@ -769,6 +800,7 @@ var MiddleLayer = class MiddleLayer {
 		const prj = this.openedProjects.get(id);
 		if (prj === void 0) throw new Error(`Project ${id} not found among opened projects`);
 		this.openedProjects.delete(id);
+		this.trackSnapshotWrite(prj.snapshotOnClose());
 		await prj.destroy();
 		this.openedProjectsList.setValue([...this.openedProjects.keys()]);
 	}
@@ -782,6 +814,12 @@ var MiddleLayer = class MiddleLayer {
 	isProjectOpened(id) {
 		return this.openedProjects.has(id);
 	}
+	/** Counters for the persisted project tree mirrors, or undefined when they are switched off.
+	*  Reads and hits are what show whether a reopen was actually warm, and the miss breakdown
+	*  says why it was not. */
+	get treeSnapshotStats() {
+		return this.env.treeSnapshots?.getStats();
+	}
 	/**
 	* Deallocates all runtime resources consumed by this object and awaits
 	* actual termination of event loops and other processes associated with
@@ -796,6 +834,7 @@ var MiddleLayer = class MiddleLayer {
 			this.sharingStateTree.terminate(),
 			this.pendingSharesTree.terminate()
 		]);
+		await this.drainSnapshotWrites(SNAPSHOT_DRAIN_TIMEOUT_MS);
 		await this.env.dispose();
 		await this.pl.close();
 	}
@@ -858,6 +897,14 @@ var MiddleLayer = class MiddleLayer {
 		runtimeCapabilities.addSupportedRequirement("requiresPFramesVersion", _milaboratories_pl_model_common.REQUIRES_PFRAMES_VERSION);
 		(0, _milaboratories_pl_model_common.registerServiceCapabilities)((flag, value) => runtimeCapabilities.addSupportedRequirement(flag, value));
 		const serviceRegistry = require_service_factories.createModelServiceRegistry({ logger });
+		const treeSnapshots = require_tree_snapshot_store.TreeSnapshotStore.create(pl, {
+			dir: ops.treeSnapshotPath,
+			maxSizeBytes: ops.treeSnapshotOps.maxSizeBytes,
+			enabled: ops.treeSnapshotOps.enabled,
+			logger
+		});
+		if (ops.treeSnapshotOps.enabled) await treeSnapshots?.evict();
+		else await require_tree_snapshot_store.TreeSnapshotStore.purge(ops.treeSnapshotPath, logger);
 		const env = {
 			pl,
 			blockEventDispatcher: new _milaboratories_ts_helpers.BlockEventDispatcher(),
@@ -878,6 +925,7 @@ var MiddleLayer = class MiddleLayer {
 			serviceRegistry,
 			quickJs,
 			projectHelper: new require_project_helper.ProjectHelper(quickJs, logger),
+			treeSnapshots,
 			dispose: async () => {
 				await serviceRegistry.dispose();
 				await retryHttpDispatcher.destroy();