@milaboratories/pl-middle-layer 1.48.11 → 1.48.13

package/dist/middle_layer/project.js

@@ -1,542 +1,511 @@
-import { isNotFoundError, isTimeoutOrCancelError, DefaultRetryOptions, ensureResourceIdNotNull, field, Pl, resourceIdToString } from '@milaboratories/pl-client';
-import { Computable } from '@milaboratories/computable';
-import { projectOverview } from './project_overview.js';
-import { randomUUID } from 'node:crypto';
-import { withProject, withProjectAuthored } from '../mutator/project.js';
-import { SynchronizedTreeState, treeDumpStats } from '@milaboratories/pl-tree';
-import { setTimeout } from 'node:timers/promises';
-import { frontendData } from './frontend_path.js';
-import { blockOutputs, getBlockParameters } from './block.js';
-import { projectFieldName } from '../model/project_model.js';
-import { cachedDeserialize, notEmpty } from '@milaboratories/ts-helpers';
-import { activeConfigs } from './active_cfg.js';
-import { NavigationStates } from './navigation_states.js';
-import { extractConfig, BLOCK_STORAGE_FACADE_VERSION } from '@platforma-sdk/model';
-import fs__default from 'node:fs/promises';
-import canonicalize from 'canonicalize';
-import { projectOverviewLight } from './project_overview_light.js';
-import { applyProjectMigrations } from '../mutator/migration.js';
+import { projectFieldName } from "../model/project_model.js";
+import { withProject, withProjectAuthored } from "../mutator/project.js";
+import { projectOverview } from "./project_overview.js";
+import { frontendData } from "./frontend_path.js";
+import { blockOutputs, getBlockParameters } from "./block.js";
+import { activeConfigs } from "./active_cfg.js";
+import { NavigationStates } from "./navigation_states.js";
+import { projectOverviewLight } from "./project_overview_light.js";
+import { applyProjectMigrations } from "../mutator/migration.js";
+import { BLOCK_STORAGE_FACADE_VERSION, extractConfig } from "@platforma-sdk/model";
+import { cachedDeserialize, notEmpty } from "@milaboratories/ts-helpers";
+import fs from "node:fs/promises";
+import { DefaultRetryOptions, Pl, ensureResourceIdNotNull, field, isNotFoundError, isTimeoutOrCancelError, resourceIdToString } from "@milaboratories/pl-client";
+import { SynchronizedTreeState, treeDumpStats } from "@milaboratories/pl-tree";
+import { Computable } from "@milaboratories/computable";
+import { randomUUID } from "node:crypto";
+import canonicalize from "canonicalize";
+import { setTimeout } from "node:timers/promises";
 
+//#region src/middle_layer/project.ts
 function stringifyForDump(object) {
-    return JSON.stringify(object, (key, value) => {
-        if (typeof value === "bigint")
-            return resourceIdToString(value);
-        else if (ArrayBuffer.isView(value) ||
-            value instanceof Int8Array ||
-            value instanceof Uint8Array ||
-            value instanceof Uint8ClampedArray ||
-            value instanceof Int16Array ||
-            value instanceof Uint16Array ||
-            value instanceof Int32Array ||
-            value instanceof Uint32Array ||
-            value instanceof Float32Array ||
-            value instanceof Float64Array ||
-            value instanceof BigInt64Array ||
-            value instanceof BigUint64Array)
-            return Buffer.from(value.buffer, value.byteOffset, value.byteLength).toString("base64");
-        else if (Buffer.isBuffer(value))
-            return value.toString("base64");
-        return value;
-    });
+	return JSON.stringify(object, (key, value) => {
+		if (typeof value === "bigint") return resourceIdToString(value);
+		else if (ArrayBuffer.isView(value) || value instanceof Int8Array || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int16Array || value instanceof Uint16Array || value instanceof Int32Array || value instanceof Uint32Array || value instanceof Float32Array || value instanceof Float64Array || value instanceof BigInt64Array || value instanceof BigUint64Array) return Buffer.from(value.buffer, value.byteOffset, value.byteLength).toString("base64");
+		else if (Buffer.isBuffer(value)) return value.toString("base64");
+		return value;
+	});
 }
 /** Data access object, to manipulate and read single opened (!) project data. */
-class Project {
-    env;
-    projectTree;
-    /** Underlying pl resource id */
-    rid;
-    /** Data for the left panel, contain basic information about block status. */
-    overview;
-    overviewLight;
-    navigationStates = new NavigationStates();
-    // null is set for deleted blocks
-    blockComputables = new Map();
-    blockFrontends = new Map();
-    activeConfigs;
-    refreshLoopResult;
-    abortController = new AbortController();
-    get destroyed() {
-        return this.abortController.signal.aborted;
-    }
-    constructor(env, rid, projectTree) {
-        this.env = env;
-        this.projectTree = projectTree;
-        this.overview = projectOverview(projectTree.entry(), this.navigationStates, env).withPreCalculatedValueTree();
-        this.overviewLight = projectOverviewLight(projectTree.entry()).withPreCalculatedValueTree();
-        this.rid = rid;
-        this.refreshLoopResult = this.refreshLoop();
-        this.refreshLoopResult.catch((err) => {
-            env.logger.warn(new Error("Error during refresh loop", { cause: err })); // TODO (safe voiding for now)
-        });
-        this.activeConfigs = activeConfigs(projectTree.entry(), env);
-    }
-    get projectLockId() {
-        return "project:" + this.rid.toString();
-    }
-    async refreshLoop() {
-        while (!this.destroyed) {
-            try {
-                await withProject(this.env.projectHelper, this.env.pl, this.rid, (prj) => {
-                    prj.doRefresh(this.env.ops.stagingRenderingRate);
-                }, { name: "doRefresh", lockId: this.projectLockId });
-                await this.activeConfigs.getValue();
-                await setTimeout(this.env.ops.projectRefreshInterval, this.abortController.signal);
-                // Block computables housekeeping
-                const overviewLight = await this.overviewLight.getValue();
-                const existingBlocks = new Set(overviewLight.listOfBlocks);
-                // Doing cleanup for deleted blocks
-                for (const blockId of this.blockComputables.keys()) {
-                    if (!existingBlocks.has(blockId)) {
-                        const computable = this.blockComputables.get(blockId);
-                        if (computable !== undefined && computable !== null)
-                            computable.fullState.resetState();
-                        this.blockComputables.set(blockId, null);
-                    }
-                }
-            }
-            catch (e) {
-                // If we're destroyed, exit gracefully regardless of error type
-                if (this.destroyed) {
-                    // Log just in case, to help with debugging if something unexpected happens during shutdown
-                    this.env.logger.warn(new Error("Error during refresh loop shutdown", { cause: e }));
-                    break;
-                }
-                if (isNotFoundError(e)) {
-                    console.warn("project refresh routine terminated, because project was externally deleted");
-                    break;
-                }
-                else if (isTimeoutOrCancelError(e)) ;
-                else {
-                    // TODO: This stops the refresh loop permanently, leaving the project broken.
-                    // Need to decide how to handle this case.
-                    throw new Error("Unexpected exception", { cause: e });
-                }
-            }
-        }
-    }
-    /**
-     * Adds new block to the project.
-     *
-     * @param blockLabel block label / title visible to the user
-     * @param blockPackSpec object describing the "block type", read more in the type docs
-     * @param before id of the block to insert new block before
-     * @param blockId internal id to be assigned for the block, this arg can be omitted
-     *                 then, randomly generated UUID will be assigned automatically
-     *
-     * @return returns newly created block id
-     * */
-    async addBlock(blockLabel, blockPackSpec, before, author = undefined, blockId = randomUUID()) {
-        const preparedBp = await this.env.bpPreparer.prepare(blockPackSpec);
-        const blockCfgContainer = await this.env.bpPreparer.getBlockConfigContainer(blockPackSpec);
-        const blockCfg = extractConfig(blockCfgContainer); // full content of this var should never be persisted
-        this.env.runtimeCapabilities.throwIfIncompatible(blockCfg.featureFlags);
-        // Build NewBlockSpec based on model API version
-        const newBlockSpec = blockCfg.modelAPIVersion === BLOCK_STORAGE_FACADE_VERSION
-            ? { storageMode: "fromModel", blockPack: preparedBp }
-            : {
-                storageMode: "legacy",
-                blockPack: preparedBp,
-                legacyState: canonicalize({
-                    args: blockCfg.initialArgs,
-                    uiState: blockCfg.initialUiState,
-                }),
-            };
-        await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, author, (mut) => {
-            return mut.addBlock({
-                id: blockId,
-                label: blockLabel,
-                renderingMode: blockCfg.renderingMode,
-            }, newBlockSpec, before);
-        }, {
-            retryOptions: {
-                ...DefaultRetryOptions,
-                backoffMultiplier: DefaultRetryOptions.backoffMultiplier * 1.1,
-            },
-            name: "addBlock",
-            lockId: this.projectLockId,
-        });
-        await this.projectTree.refreshState();
-        return blockId;
-    }
-    /**
-     * Duplicates an existing block by copying all its fields and state.
-     * This method works at the mutator level for efficient block copying.
-     *
-     * @param originalBlockId id of the block to duplicate
-     * @param before id of the block to insert new block before
-     * @param author author marker for the duplication operation
-     * @param newBlockId internal id to be assigned for the duplicated block,
-     *                   if omitted, a randomly generated UUID will be assigned
-     *
-     * @return returns newly created block id
-     * */
-    async duplicateBlock(originalBlockId, before, author = undefined, newBlockId = randomUUID()) {
-        await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, author, (mut) => mut.duplicateBlock(originalBlockId, newBlockId, before), { name: "duplicateBlock", lockId: this.projectLockId });
-        await this.projectTree.refreshState();
-        return newBlockId;
-    }
-    /**
-     * Update block to new block pack, optionally resetting args and ui state to
-     * initial values
-     * */
-    async updateBlockPack(blockId, blockPackSpec, resetArgs = false, author) {
-        const preparedBp = await this.env.bpPreparer.prepare(blockPackSpec);
-        const blockCfg = extractConfig(await this.env.bpPreparer.getBlockConfigContainer(blockPackSpec));
-        this.env.runtimeCapabilities.throwIfIncompatible(blockCfg.featureFlags);
-        // resetState signals to mutator to reset storage
-        // For v2+ blocks: mutator gets initial storage directly via getInitialStorageInVM
-        // For v1 blocks: we pass the legacy state format
-        const resetState = resetArgs
-            ? {
-                state: blockCfg.modelAPIVersion === 1
-                    ? { args: blockCfg.initialArgs, uiState: blockCfg.initialUiState }
-                    : {},
-            }
-            : undefined;
-        await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, author, (mut) => mut.migrateBlockPack(blockId, preparedBp, resetState), { name: "updateBlockPack", lockId: this.projectLockId });
-        await this.projectTree.refreshState();
-    }
-    /** Deletes a block with all associated data. */
-    async deleteBlock(blockId, author) {
-        await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, author, (mut) => mut.deleteBlock(blockId), { name: "deleteBlock", lockId: this.projectLockId });
-        this.navigationStates.deleteBlock(blockId);
-        await this.projectTree.refreshState();
-    }
-    /**
-     * Updates block order according to the given array of block ids.
-     *
-     * Provided array must contain exactly the same set of ids current project cosists of,
-     * an error will be thrown instead.
-     */
-    async reorderBlocks(blocks, author) {
-        await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, author, (mut) => {
-            const currentStructure = mut.structure;
-            if (currentStructure.groups.length !== 1)
-                throw new Error("Unexpected project structure, non-singular block group");
-            const currentGroup = currentStructure.groups[0];
-            if (currentGroup.blocks.length !== blocks.length)
-                throw new Error(`Length mismatch: ${currentGroup.blocks.length} !== ${blocks.length}`);
-            if (new Set(blocks).size !== blocks.length)
-                throw new Error(`Repeated block ids`);
-            const newStructure = {
-                groups: [
-                    {
-                        id: currentGroup.id,
-                        label: currentGroup.label,
-                        blocks: blocks.map((blockId) => {
-                            const block = currentGroup.blocks.find((b) => b.id === blockId);
-                            if (block === undefined)
-                                throw new Error(`Can't find block: ${blockId}`);
-                            return block;
-                        }),
-                    },
-                ],
-            };
-            mut.updateStructure(newStructure);
-        }, { name: "reorderBlocks", lockId: this.projectLockId });
-        await this.projectTree.refreshState();
-    }
-    /**
-     * Renders production part of the block starting all connected heavy computations.
-     * Upstream blocks of the specified block will be started automatically if in
-     * stale state.
-     * */
-    async runBlock(blockId) {
-        await withProject(this.env.projectHelper, this.env.pl, this.rid, (mut) => mut.renderProduction([blockId], true), { name: "runBlock", lockId: this.projectLockId });
-        await this.projectTree.refreshState();
-    }
-    /**
-     * Stops the block if it is running by destroying its production state. All
-     * its downstreams will also be destroyed or moved to limbo if already
-     * calculated.
-     * */
-    async stopBlock(blockId) {
-        await withProject(this.env.projectHelper, this.env.pl, this.rid, (mut) => mut.stopProduction(blockId), { name: "stopBlock", lockId: this.projectLockId });
-        await this.projectTree.refreshState();
-    }
-    /**
-     * @deprecated Use mutateBlockStorage() for V3 blocks.
-     * Sets block args, and changes whole project state accordingly.
-     * Along with setting arguments one can specify author marker, that will be
-     * transactionally associated with the block, to facilitate conflict resolution
-     * in collaborative editing scenario.
-     * */
-    async setBlockArgs(blockId, args, author) {
-        await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, author, (mut) => {
-            const state = mut.mergeBlockState(blockId, { args });
-            mut.setStates([{ modelAPIVersion: 1, blockId, state }]);
-        }, { name: "setBlockArgs", lockId: this.projectLockId });
-        await this.projectTree.refreshState();
-    }
-    /**
-     * @deprecated Use mutateBlockStorage() for V3 blocks.
-     * Sets ui block state associated with the block.
-     * Along with setting arguments one can specify author marker, that will be
-     * transactionally associated with the block, to facilitate conflict resolution
-     * in collaborative editing scenario.
-     * */
-    async setUiState(blockId, uiState, author) {
-        await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, author, (mut) => {
-            const state = mut.mergeBlockState(blockId, { uiState });
-            mut.setStates([{ modelAPIVersion: 1, blockId, state }]);
-        }, { name: "setUiState", lockId: this.projectLockId });
-        await this.projectTree.refreshState();
-    }
-    /**
-     * @deprecated Use mutateBlockStorage() for V3 blocks.
-     * Sets block args and ui state, and changes the whole project state accordingly.
-     * Along with setting arguments one can specify author marker, that will be
-     * transactionally associated with the block, to facilitate conflict resolution
-     * in collaborative editing scenario.
-     * */
-    async setBlockArgsAndUiState(blockId, args, // keep for v1/v2 compatibility
-    uiState, // keep for v1/v2 compatibility
-    author) {
-        // Normalize to unified state format { args, uiState } for v1/v2 blocks
-        const state = { args, uiState };
-        await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, author, (mut) => {
-            mut.setStates([{ modelAPIVersion: 1, blockId, state }]);
-        }, { name: "setBlockArgsAndUiState", lockId: this.projectLockId });
-        await this.projectTree.refreshState();
-    }
-    /**
-     * Sets navigation state.
-     * */
-    //
-    async setNavigationState(blockId, state) {
-        this.navigationStates.setState(blockId, state);
-    }
-    /**
-     * Mutates block storage for Model API v3 blocks.
-     * Applies a storage operation (e.g., 'update-data') which triggers
-     * args derivation (args(data) and prerunArgs(data)).
-     * The derived args are stored atomically with the data.
-     *
-     * @param blockId - The block ID
-     * @param payload - Storage mutation payload with operation and value
-     * @param author - Optional author marker for collaborative editing
-     */
-    async mutateBlockStorage(blockId, payload, author) {
-        await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, author, (mut) => mut.setStates([{ modelAPIVersion: 2, blockId, payload }]), { name: "mutateBlockStorage", lockId: this.projectLockId });
-        await this.projectTree.refreshState();
-    }
-    /** Update block settings */
-    async setBlockSettings(blockId, newValue) {
-        await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, undefined, (mut) => {
-            mut.setBlockSettings(blockId, newValue);
-        }, { name: "setBlockSettings" });
-        await this.projectTree.refreshState();
-    }
-    /**
-     * Sets raw block storage content directly.
-     * This bypasses all normalization and VM transformations.
-     *
-     * @param blockId The block to set storage for
-     * @param rawStorageJson Raw storage as JSON string
-     */
-    async setBlockStorageRaw(blockId, rawStorageJson) {
-        await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, undefined, (mut) => {
-            mut.setBlockStorageRaw(blockId, rawStorageJson);
-        }, { name: "setBlockStorageRaw" });
-        await this.projectTree.refreshState();
-    }
-    /** Resets arguments and ui state of the block to initial state */
-    async resetBlockArgsAndUiState(blockId, author) {
-        await this.env.pl.withWriteTx("BlockInputsReset", async (tx) => {
-            // reading default arg values from block pack
-            const bpHolderRid = ensureResourceIdNotNull((await tx.getField(field(this.rid, projectFieldName(blockId, "blockPack")))).value);
-            const bpRid = ensureResourceIdNotNull((await tx.getField(field(bpHolderRid, Pl.HolderRefField))).value);
-            const bpData = await tx.getResourceData(bpRid, false);
-            const config = extractConfig(cachedDeserialize(notEmpty(bpData.data)).config);
-            await withProjectAuthored(this.env.projectHelper, tx, this.rid, author, (prj) => {
-                if (config.modelAPIVersion === BLOCK_STORAGE_FACADE_VERSION) {
-                    // V2+: Reset to initial storage via VM
-                    prj.resetToInitialStorage(blockId);
-                }
-                else {
-                    // V1: Use legacy state format
-                    const initialState = { args: config.initialArgs, uiState: config.initialUiState };
-                    prj.setStates([{ modelAPIVersion: 1, blockId, state: initialState }]);
-                }
-            }, { name: "resetBlockArgsAndUiState", lockId: this.projectLockId });
-            await tx.commit();
-        });
-        await this.projectTree.refreshState();
-    }
-    getBlockComputables(blockId) {
-        const cached = this.blockComputables.get(blockId);
-        if (cached === null)
-            throw new Error(`Block ${blockId} is deleted`);
-        if (cached === undefined) {
-            // state consists of inputs (args + ui state) and outputs
-            const outputs = blockOutputs(this.projectTree.entry(), blockId, this.env);
-            const fullState = Computable.make((ctx) => {
-                return {
-                    parameters: getBlockParameters(this.projectTree.entry(), blockId, ctx),
-                    outputs,
-                    navigationState: this.navigationStates.getState(blockId),
-                    overview: this.overview,
-                };
-            }, {
-                postprocessValue: (v) => {
-                    const blockOverview = v.overview?.blocks?.find((b) => b.id == blockId);
-                    const sdkVersion = blockOverview?.sdkVersion;
-                    const storageDebugView = blockOverview?.storageDebugView;
-                    const toString = sdkVersion && shouldStillUseStringErrors(sdkVersion);
-                    const newOutputs = toString && v.outputs !== undefined ? convertErrorsToStrings(v.outputs) : v.outputs;
-                    return {
-                        ...v.parameters,
-                        outputs: newOutputs,
-                        navigationState: v.navigationState,
-                        storageDebugView,
-                    };
-                },
-            });
-            const computables = {
-                fullState: fullState.withPreCalculatedValueTree(),
-            };
-            this.blockComputables.set(blockId, computables);
-            return computables;
-        }
-        return cached;
-    }
-    /**
-     * Returns a computable, that can be used to retrieve and watch full block state,
-     * including outputs, arguments, ui state.
-     * */
-    getBlockState(blockId) {
-        return this.getBlockComputables(blockId).fullState;
-    }
-    /**
-     * Returns a computable, that can be used to retrieve and watch path of the
-     * folder containing frontend code.
-     * */
-    getBlockFrontend(blockId) {
-        const cached = this.blockFrontends.get(blockId);
-        if (cached === undefined) {
-            const fd = frontendData(this.projectTree.entry(), blockId, this.env).withPreCalculatedValueTree();
-            this.blockFrontends.set(blockId, fd);
-            return fd;
-        }
-        return cached;
-    }
-    /** Called by middle layer on close */
-    async destroy() {
-        // terminating the project service loop
-        this.abortController.abort();
-        try {
-            await this.refreshLoopResult;
-        }
-        catch (e) {
-            // Error was already logged in the constructor's catch handler, but log again for context
-            this.env.logger.warn(new Error("Refresh loop had terminated with error before destroy", { cause: e }));
-        }
-        // terminating the synchronized project tree
-        try {
-            await this.projectTree.terminate();
-        }
-        catch (e) {
-            // TODO: SynchronizedTreeState.terminate() can throw if mainLoop had an error before termination
-            // Log error but continue cleanup - we must clean up remaining resources
-            this.env.logger.warn(new Error("Project tree termination failed", { cause: e }));
-        }
-        // the following will deregister all external resource holders, like
-        // downloaded files, running uploads and alike
-        this.overview.resetState();
-        this.blockFrontends.forEach((c) => c.resetState());
-        this.blockComputables.forEach((c) => {
-            if (c !== null)
-                c.fullState.resetState();
-        });
-        this.activeConfigs.resetState();
-    }
-    /** @deprecated */
-    async destroyAndAwaitTermination() {
-        await this.destroy();
-    }
-    dumpState() {
-        return this.projectTree.dumpState();
-    }
-    static async init(env, rid) {
-        // Applying migrations to the project resource, if needed
-        await applyProjectMigrations(env.pl, rid);
-        // Doing a no-op mutation to apply all migration and schema fixes
-        await withProject(env.projectHelper, env.pl, rid, (_) => { }, { name: "init" });
-        // Loading project tree
-        const projectTree = await SynchronizedTreeState.init(env.pl, rid, {
-            ...env.ops.defaultTreeOptions,
-            pruning: projectTreePruning(env.logger),
-        }, env.logger);
-        if (env.ops.debugOps.dumpInitialTreeState) {
-            const state = projectTree.dumpState();
-            state.sort((a, b) => (b.data?.byteLength ?? 0) - (a.data?.byteLength ?? 0));
-            const stats = treeDumpStats(state);
-            await fs__default.writeFile(`${resourceIdToString(rid)}.json`, stringifyForDump(state));
-            await fs__default.writeFile(`${resourceIdToString(rid)}.stats.json`, stringifyForDump(stats));
-        }
-        return new Project(env, rid, projectTree);
-    }
-}
+var Project = class Project {
+	/** Underlying pl resource id */
+	rid;
+	/** Data for the left panel, contain basic information about block status. */
+	overview;
+	overviewLight;
+	navigationStates = new NavigationStates();
+	blockComputables = /* @__PURE__ */ new Map();
+	blockFrontends = /* @__PURE__ */ new Map();
+	activeConfigs;
+	refreshLoopResult;
+	abortController = new AbortController();
+	get destroyed() {
+		return this.abortController.signal.aborted;
+	}
+	constructor(env, rid, projectTree) {
+		this.env = env;
+		this.projectTree = projectTree;
+		this.overview = projectOverview(projectTree.entry(), this.navigationStates, env).withPreCalculatedValueTree();
+		this.overviewLight = projectOverviewLight(projectTree.entry()).withPreCalculatedValueTree();
+		this.rid = rid;
+		this.refreshLoopResult = this.refreshLoop();
+		this.refreshLoopResult.catch((err) => {
+			env.logger.warn(new Error("Error during refresh loop", { cause: err }));
+		});
+		this.activeConfigs = activeConfigs(projectTree.entry(), env);
+	}
+	get projectLockId() {
+		return "project:" + this.rid.toString();
+	}
+	async refreshLoop() {
+		while (!this.destroyed) try {
+			await withProject(this.env.projectHelper, this.env.pl, this.rid, (prj) => {
+				prj.doRefresh(this.env.ops.stagingRenderingRate);
+			}, {
+				name: "doRefresh",
+				lockId: this.projectLockId
+			});
+			await this.activeConfigs.getValue();
+			await setTimeout(this.env.ops.projectRefreshInterval, this.abortController.signal);
+			const overviewLight = await this.overviewLight.getValue();
+			const existingBlocks = new Set(overviewLight.listOfBlocks);
+			for (const blockId of this.blockComputables.keys()) if (!existingBlocks.has(blockId)) {
+				const computable = this.blockComputables.get(blockId);
+				if (computable !== void 0 && computable !== null) computable.fullState.resetState();
+				this.blockComputables.set(blockId, null);
+			}
+		} catch (e) {
+			if (this.destroyed) {
+				this.env.logger.warn(new Error("Error during refresh loop shutdown", { cause: e }));
+				break;
+			}
+			if (isNotFoundError(e)) {
+				console.warn("project refresh routine terminated, because project was externally deleted");
+				break;
+			} else if (isTimeoutOrCancelError(e)) {} else throw new Error("Unexpected exception", { cause: e });
+		}
+	}
+	/**
+	* Adds new block to the project.
+	*
+	* @param blockLabel block label / title visible to the user
+	* @param blockPackSpec object describing the "block type", read more in the type docs
+	* @param before id of the block to insert new block before
+	* @param blockId internal id to be assigned for the block, this arg can be omitted
+	*                 then, randomly generated UUID will be assigned automatically
+	*
+	* @return returns newly created block id
+	* */
+	async addBlock(blockLabel, blockPackSpec, before, author = void 0, blockId = randomUUID()) {
+		const preparedBp = await this.env.bpPreparer.prepare(blockPackSpec);
+		const blockCfg = extractConfig(await this.env.bpPreparer.getBlockConfigContainer(blockPackSpec));
+		this.env.runtimeCapabilities.throwIfIncompatible(blockCfg.featureFlags);
+		const newBlockSpec = blockCfg.modelAPIVersion === BLOCK_STORAGE_FACADE_VERSION ? {
+			storageMode: "fromModel",
+			blockPack: preparedBp
+		} : {
+			storageMode: "legacy",
+			blockPack: preparedBp,
+			legacyState: canonicalize({
+				args: blockCfg.initialArgs,
+				uiState: blockCfg.initialUiState
+			})
+		};
+		await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, author, (mut) => {
+			return mut.addBlock({
+				id: blockId,
+				label: blockLabel,
+				renderingMode: blockCfg.renderingMode
+			}, newBlockSpec, before);
+		}, {
+			retryOptions: {
+				...DefaultRetryOptions,
+				backoffMultiplier: DefaultRetryOptions.backoffMultiplier * 1.1
+			},
+			name: "addBlock",
+			lockId: this.projectLockId
+		});
+		await this.projectTree.refreshState();
+		return blockId;
+	}
+	/**
+	* Duplicates an existing block by copying all its fields and state.
+	* This method works at the mutator level for efficient block copying.
+	*
+	* @param originalBlockId id of the block to duplicate
+	* @param before id of the block to insert new block before
+	* @param author author marker for the duplication operation
+	* @param newBlockId internal id to be assigned for the duplicated block,
+	*                   if omitted, a randomly generated UUID will be assigned
+	*
+	* @return returns newly created block id
+	* */
+	async duplicateBlock(originalBlockId, before, author = void 0, newBlockId = randomUUID()) {
+		await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, author, (mut) => mut.duplicateBlock(originalBlockId, newBlockId, before), {
+			name: "duplicateBlock",
+			lockId: this.projectLockId
+		});
+		await this.projectTree.refreshState();
+		return newBlockId;
+	}
+	/**
+	* Update block to new block pack, optionally resetting args and ui state to
+	* initial values
+	* */
+	async updateBlockPack(blockId, blockPackSpec, resetArgs = false, author) {
+		const preparedBp = await this.env.bpPreparer.prepare(blockPackSpec);
+		const blockCfg = extractConfig(await this.env.bpPreparer.getBlockConfigContainer(blockPackSpec));
+		this.env.runtimeCapabilities.throwIfIncompatible(blockCfg.featureFlags);
+		const resetState = resetArgs ? { state: blockCfg.modelAPIVersion === 1 ? {
+			args: blockCfg.initialArgs,
+			uiState: blockCfg.initialUiState
+		} : {} } : void 0;
+		await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, author, (mut) => mut.migrateBlockPack(blockId, preparedBp, resetState), {
+			name: "updateBlockPack",
+			lockId: this.projectLockId
+		});
+		await this.projectTree.refreshState();
+	}
+	/** Deletes a block with all associated data. */
+	async deleteBlock(blockId, author) {
+		await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, author, (mut) => mut.deleteBlock(blockId), {
+			name: "deleteBlock",
+			lockId: this.projectLockId
+		});
+		this.navigationStates.deleteBlock(blockId);
+		await this.projectTree.refreshState();
+	}
+	/**
+	* Updates block order according to the given array of block ids.
+	*
+	* Provided array must contain exactly the same set of ids current project cosists of,
+	* an error will be thrown instead.
+	*/
+	async reorderBlocks(blocks, author) {
+		await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, author, (mut) => {
+			const currentStructure = mut.structure;
+			if (currentStructure.groups.length !== 1) throw new Error("Unexpected project structure, non-singular block group");
+			const currentGroup = currentStructure.groups[0];
+			if (currentGroup.blocks.length !== blocks.length) throw new Error(`Length mismatch: ${currentGroup.blocks.length} !== ${blocks.length}`);
+			if (new Set(blocks).size !== blocks.length) throw new Error(`Repeated block ids`);
+			const newStructure = { groups: [{
+				id: currentGroup.id,
+				label: currentGroup.label,
+				blocks: blocks.map((blockId) => {
+					const block = currentGroup.blocks.find((b) => b.id === blockId);
+					if (block === void 0) throw new Error(`Can't find block: ${blockId}`);
+					return block;
+				})
+			}] };
+			mut.updateStructure(newStructure);
+		}, {
+			name: "reorderBlocks",
+			lockId: this.projectLockId
+		});
+		await this.projectTree.refreshState();
+	}
+	/**
+	* Renders production part of the block starting all connected heavy computations.
+	* Upstream blocks of the specified block will be started automatically if in
+	* stale state.
+	* */
+	async runBlock(blockId) {
+		await withProject(this.env.projectHelper, this.env.pl, this.rid, (mut) => mut.renderProduction([blockId], true), {
+			name: "runBlock",
+			lockId: this.projectLockId
+		});
+		await this.projectTree.refreshState();
+	}
+	/**
+	* Stops the block if it is running by destroying its production state. All
+	* its downstreams will also be destroyed or moved to limbo if already
+	* calculated.
+	* */
+	async stopBlock(blockId) {
+		await withProject(this.env.projectHelper, this.env.pl, this.rid, (mut) => mut.stopProduction(blockId), {
+			name: "stopBlock",
+			lockId: this.projectLockId
+		});
+		await this.projectTree.refreshState();
+	}
+	/**
+	* @deprecated Use mutateBlockStorage() for V3 blocks.
+	* Sets block args, and changes whole project state accordingly.
+	* Along with setting arguments one can specify author marker, that will be
+	* transactionally associated with the block, to facilitate conflict resolution
+	* in collaborative editing scenario.
+	* */
+	async setBlockArgs(blockId, args, author) {
+		await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, author, (mut) => {
+			const state = mut.mergeBlockState(blockId, { args });
+			mut.setStates([{
+				modelAPIVersion: 1,
+				blockId,
+				state
+			}]);
+		}, {
+			name: "setBlockArgs",
+			lockId: this.projectLockId
+		});
+		await this.projectTree.refreshState();
+	}
+	/**
+	* @deprecated Use mutateBlockStorage() for V3 blocks.
+	* Sets ui block state associated with the block.
+	* Along with setting arguments one can specify author marker, that will be
+	* transactionally associated with the block, to facilitate conflict resolution
+	* in collaborative editing scenario.
+	* */
+	async setUiState(blockId, uiState, author) {
+		await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, author, (mut) => {
+			const state = mut.mergeBlockState(blockId, { uiState });
+			mut.setStates([{
+				modelAPIVersion: 1,
+				blockId,
+				state
+			}]);
+		}, {
+			name: "setUiState",
+			lockId: this.projectLockId
+		});
+		await this.projectTree.refreshState();
+	}
+	/**
+	* @deprecated Use mutateBlockStorage() for V3 blocks.
+	* Sets block args and ui state, and changes the whole project state accordingly.
+	* Along with setting arguments one can specify author marker, that will be
+	* transactionally associated with the block, to facilitate conflict resolution
+	* in collaborative editing scenario.
+	* */
+	async setBlockArgsAndUiState(blockId, args, uiState, author) {
+		const state = {
+			args,
+			uiState
+		};
+		await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, author, (mut) => {
+			mut.setStates([{
+				modelAPIVersion: 1,
+				blockId,
+				state
+			}]);
+		}, {
+			name: "setBlockArgsAndUiState",
+			lockId: this.projectLockId
+		});
+		await this.projectTree.refreshState();
+	}
+	/**
+	* Sets navigation state.
+	* */
+	async setNavigationState(blockId, state) {
+		this.navigationStates.setState(blockId, state);
+	}
+	/**
+	* Mutates block storage for Model API v3 blocks.
+	* Applies a storage operation (e.g., 'update-data') which triggers
+	* args derivation (args(data) and prerunArgs(data)).
+	* The derived args are stored atomically with the data.
+	*
+	* @param blockId - The block ID
+	* @param payload - Storage mutation payload with operation and value
+	* @param author - Optional author marker for collaborative editing
+	*/
+	async mutateBlockStorage(blockId, payload, author) {
+		await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, author, (mut) => mut.setStates([{
+			modelAPIVersion: 2,
+			blockId,
+			payload
+		}]), {
+			name: "mutateBlockStorage",
+			lockId: this.projectLockId
+		});
+		await this.projectTree.refreshState();
+	}
+	/** Update block settings */
+	async setBlockSettings(blockId, newValue) {
+		await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, void 0, (mut) => {
+			mut.setBlockSettings(blockId, newValue);
+		}, { name: "setBlockSettings" });
+		await this.projectTree.refreshState();
+	}
+	/**
+	* Sets raw block storage content directly.
+	* This bypasses all normalization and VM transformations.
+	*
+	* @param blockId The block to set storage for
+	* @param rawStorageJson Raw storage as JSON string
+	*/
+	async setBlockStorageRaw(blockId, rawStorageJson) {
+		await withProjectAuthored(this.env.projectHelper, this.env.pl, this.rid, void 0, (mut) => {
+			mut.setBlockStorageRaw(blockId, rawStorageJson);
+		}, { name: "setBlockStorageRaw" });
+		await this.projectTree.refreshState();
+	}
+	/** Resets arguments and ui state of the block to initial state */
+	async resetBlockArgsAndUiState(blockId, author) {
+		await this.env.pl.withWriteTx("BlockInputsReset", async (tx) => {
+			const bpHolderRid = ensureResourceIdNotNull((await tx.getField(field(this.rid, projectFieldName(blockId, "blockPack")))).value);
+			const bpRid = ensureResourceIdNotNull((await tx.getField(field(bpHolderRid, Pl.HolderRefField))).value);
+			const config = extractConfig(cachedDeserialize(notEmpty((await tx.getResourceData(bpRid, false)).data)).config);
+			await withProjectAuthored(this.env.projectHelper, tx, this.rid, author, (prj) => {
+				if (config.modelAPIVersion === BLOCK_STORAGE_FACADE_VERSION) prj.resetToInitialStorage(blockId);
+				else {
+					const initialState = {
+						args: config.initialArgs,
+						uiState: config.initialUiState
+					};
+					prj.setStates([{
+						modelAPIVersion: 1,
+						blockId,
+						state: initialState
+					}]);
+				}
+			}, {
+				name: "resetBlockArgsAndUiState",
+				lockId: this.projectLockId
+			});
+			await tx.commit();
+		});
+		await this.projectTree.refreshState();
+	}
+	getBlockComputables(blockId) {
+		const cached = this.blockComputables.get(blockId);
+		if (cached === null) throw new Error(`Block ${blockId} is deleted`);
+		if (cached === void 0) {
+			const outputs = blockOutputs(this.projectTree.entry(), blockId, this.env);
+			const computables = { fullState: Computable.make((ctx) => {
+				return {
+					parameters: getBlockParameters(this.projectTree.entry(), blockId, ctx),
+					outputs,
+					navigationState: this.navigationStates.getState(blockId),
+					overview: this.overview
+				};
+			}, { postprocessValue: (v) => {
+				const blockOverview = v.overview?.blocks?.find((b) => b.id == blockId);
+				const sdkVersion = blockOverview?.sdkVersion;
+				const storageDebugView = blockOverview?.storageDebugView;
+				const newOutputs = sdkVersion && shouldStillUseStringErrors(sdkVersion) && v.outputs !== void 0 ? convertErrorsToStrings(v.outputs) : v.outputs;
+				return {
+					...v.parameters,
+					outputs: newOutputs,
+					navigationState: v.navigationState,
+					storageDebugView
+				};
+			} }).withPreCalculatedValueTree() };
+			this.blockComputables.set(blockId, computables);
+			return computables;
+		}
+		return cached;
+	}
+	/**
+	* Returns a computable, that can be used to retrieve and watch full block state,
+	* including outputs, arguments, ui state.
+	* */
+	getBlockState(blockId) {
+		return this.getBlockComputables(blockId).fullState;
+	}
+	/**
+	* Returns a computable, that can be used to retrieve and watch path of the
+	* folder containing frontend code.
+	* */
+	getBlockFrontend(blockId) {
+		const cached = this.blockFrontends.get(blockId);
+		if (cached === void 0) {
+			const fd = frontendData(this.projectTree.entry(), blockId, this.env).withPreCalculatedValueTree();
+			this.blockFrontends.set(blockId, fd);
+			return fd;
+		}
+		return cached;
+	}
+	/** Called by middle layer on close */
+	async destroy() {
+		this.abortController.abort();
+		try {
+			await this.refreshLoopResult;
+		} catch (e) {
+			this.env.logger.warn(new Error("Refresh loop had terminated with error before destroy", { cause: e }));
+		}
+		try {
+			await this.projectTree.terminate();
+		} catch (e) {
+			this.env.logger.warn(new Error("Project tree termination failed", { cause: e }));
+		}
+		this.overview.resetState();
+		this.blockFrontends.forEach((c) => c.resetState());
+		this.blockComputables.forEach((c) => {
+			if (c !== null) c.fullState.resetState();
+		});
+		this.activeConfigs.resetState();
+	}
+	/** @deprecated */
+	async destroyAndAwaitTermination() {
+		await this.destroy();
+	}
+	dumpState() {
+		return this.projectTree.dumpState();
+	}
+	static async init(env, rid) {
+		await applyProjectMigrations(env.pl, rid);
+		await withProject(env.projectHelper, env.pl, rid, (_) => {}, { name: "init" });
+		const projectTree = await SynchronizedTreeState.init(env.pl, rid, {
+			...env.ops.defaultTreeOptions,
+			pruning: projectTreePruning(env.logger)
+		}, env.logger);
+		if (env.ops.debugOps.dumpInitialTreeState) {
+			const state = projectTree.dumpState();
+			state.sort((a, b) => (b.data?.byteLength ?? 0) - (a.data?.byteLength ?? 0));
+			const stats = treeDumpStats(state);
+			await fs.writeFile(`${resourceIdToString(rid)}.json`, stringifyForDump(state));
+			await fs.writeFile(`${resourceIdToString(rid)}.stats.json`, stringifyForDump(stats));
+		}
+		return new Project(env, rid, projectTree);
+	}
+};
 function projectTreePruning(logger) {
-    return (r) => {
-        if (r.fields.length > 1000)
-            logger.warn(`resource with excessive field count: type=${r.type.name} id=${r.id} fields=${r.fields.length}` +
-                ` names=[${r.fields
-                    .slice(0, 10)
-                    .map((f) => f.name)
-                    .join(", ")}, ...]`);
-        if (r.type.name.startsWith("StreamWorkdir/"))
-            return [];
-        switch (r.type.name) {
-            case "BlockPackCustom":
-                return r.fields.filter((f) => f.name !== "template");
-            case "UserProject":
-                return r.fields.filter((f) => !f.name.startsWith("__serviceTemplate"));
-            case "Blob":
-                return [];
-            default:
-                return r.fields;
-        }
-    };
+	return (r) => {
+		if (r.fields.length > 1e3) logger.warn(`resource with excessive field count: type=${r.type.name} id=${r.id} fields=${r.fields.length} names=[${r.fields.slice(0, 10).map((f) => f.name).join(", ")}, ...]`);
+		if (r.type.name.startsWith("StreamWorkdir/")) return [];
+		switch (r.type.name) {
+			case "BlockPackCustom": return r.fields.filter((f) => f.name !== "template");
+			case "UserProject": return r.fields.filter((f) => !f.name.startsWith("__serviceTemplate"));
+			case "Blob": return [];
+			default: return r.fields;
+		}
+	};
 }
 /** Returns true if sdk version of the block is old and we need to convert
- * ErrorLike errors to strings like it was.
- * We need it for keeping old blocks and new UI compatibility. */
+* ErrorLike errors to strings like it was.
+* We need it for keeping old blocks and new UI compatibility. */
 function shouldStillUseStringErrors(sdkVersion) {
-    return !isVersionGreater(sdkVersion, "1.26.0");
+	return !isVersionGreater(sdkVersion, "1.26.0");
 }
 /** Checks if sdk version is greater that a target version. */
 function isVersionGreater(sdkVersion, targetVersion) {
-    const version = sdkVersion.split(".").map(Number);
-    const target = targetVersion.split(".").map(Number);
-    return (version[0] > target[0] ||
-        (version[0] === target[0] && version[1] > target[1]) ||
-        (version[0] === target[0] && version[1] === target[1] && version[2] > target[2]));
+	const version = sdkVersion.split(".").map(Number);
+	const target = targetVersion.split(".").map(Number);
+	return version[0] > target[0] || version[0] === target[0] && version[1] > target[1] || version[0] === target[0] && version[1] === target[1] && version[2] > target[2];
 }
 /** Converts ErrorLike errors to strings in the outputs like it was in old ML versions. */
 function convertErrorsToStrings(outputs) {
-    const result = {};
-    for (const [key, val] of Object.entries(outputs)) {
-        if (val.ok) {
-            result[key] = val;
-            continue;
-        }
-        result[key] = {
-            ok: false,
-            errors: val.errors.map((e) => {
-                if (typeof e === "string") {
-                    return e;
-                }
-                else if (e.type == "PlError" && e.fullMessage !== undefined) {
-                    return e.fullMessage;
-                }
-                return e.message;
-            }),
-            moreErrors: val.moreErrors,
-        };
-    }
-    return result;
+	const result = {};
+	for (const [key, val] of Object.entries(outputs)) {
+		if (val.ok) {
+			result[key] = val;
+			continue;
+		}
+		result[key] = {
+			ok: false,
+			errors: val.errors.map((e) => {
+				if (typeof e === "string") return e;
+				else if (e.type == "PlError" && e.fullMessage !== void 0) return e.fullMessage;
+				return e.message;
+			}),
+			moreErrors: val.moreErrors
+		};
+	}
+	return result;
 }
 
+//#endregion
 export { Project };
-//# sourceMappingURL=project.js.map
+//# sourceMappingURL=project.js.map