@powerhousedao/powerhouse-vetra-packages 6.2.0-dev.10 → 6.2.0-dev.11

package/dist/browser/{document-drive-CDaY4aIj.js → document-drive-sTKoi6L4.js}

@@ -2963,6 +2963,21 @@ var InvalidActionInputZodError = class extends InvalidActionInputError {
 		this.name = "InvalidActionInputZodError";
 	}
 };
+/**
+* Error thrown when attempting to downgrade a document version.
+*/
+var DowngradeNotSupportedError = class extends Error {
+	documentType;
+	fromVersion;
+	toVersion;
+	constructor(documentType, fromVersion, toVersion) {
+		super(`Downgrade not supported for ${documentType}: cannot upgrade from version ${fromVersion} to ${toVersion}`);
+		this.name = "DowngradeNotSupportedError";
+		this.documentType = documentType;
+		this.fromVersion = fromVersion;
+		this.toVersion = toVersion;
+	}
+};
 var HashMismatchError = class extends Error {
 	_scope;
 	_document;
@@ -5801,6 +5816,280 @@ const documentModelStateReducer = (state, action) => {
 	}
 };
 const documentModelReducer = createReducer(documentModelStateReducer);
+function applyInitialState(document, action) {
+	const input = action.input;
+	const newState = input.initialState || input.state;
+	if (newState) {
+		document.state = {
+			...document.state,
+			...newState
+		};
+		document.initialState = document.state;
+	}
+}
+/**
+* Applies an UPGRADE_DOCUMENT action to a document.
+* Handles all upgrade scenarios including initial upgrades, no-ops, and multi-step upgrades.
+*
+* Behavior based on fromVersion/toVersion:
+* - fromVersion === toVersion (and fromVersion > 0): No-op - return unchanged document
+* - fromVersion > toVersion: Throw DowngradeNotSupportedError
+* - All other cases: Apply upgradePath transitions (if provided), then apply initialState, set version
+*/
+function applyUpgradeDocumentAction(document, action, upgradePath) {
+	const fromVersion = action.input.fromVersion;
+	const toVersion = action.input.toVersion;
+	if (fromVersion === toVersion && fromVersion > 0) return document;
+	if (fromVersion > toVersion) throw new DowngradeNotSupportedError(document.header.documentType, fromVersion, toVersion);
+	if (upgradePath) for (const transition of upgradePath) document = transition.upgradeReducer(document, action);
+	applyInitialState(document, action);
+	document.state.document = {
+		...document.state.document,
+		version: toVersion
+	};
+	return document;
+}
+/**
+* Applies a DELETE_DOCUMENT action to a document.
+* Marks the document as deleted in the document scope state.
+*/
+function applyDeleteDocumentAction(document, action) {
+	const deletedAt = action.timestampUtcMs || (/* @__PURE__ */ new Date()).toISOString();
+	document.state = {
+		...document.state,
+		document: {
+			...document.state.document,
+			isDeleted: true,
+			deletedAtUtcIso: deletedAt
+		}
+	};
+	return document;
+}
+/**
+* Computes the ordered list of upgrade transitions needed to move from
+* fromVersion to toVersion using the provided manifest.
+* Walks keys v(fromVersion+1)..v(toVersion) and throws a descriptive Error
+* if the manifest is absent or any step is missing.
+*/
+function computeUpgradeTransitions(manifest, fromVersion, toVersion) {
+	if (!manifest) throw new Error(`No upgrade manifest provided for transition from version ${fromVersion} to ${toVersion}`);
+	const transitions = [];
+	const upgrades = manifest.upgrades;
+	for (let v = fromVersion + 1; v <= toVersion; v++) {
+		const key = `v${v}`;
+		const transition = upgrades[key];
+		if (!transition) throw new Error(`Upgrade manifest for "${manifest.documentType}" is missing step "${key}" (from v${fromVersion} to v${toVersion}). Available keys: ${Object.keys(upgrades).join(", ")}`);
+		transitions.push(transition);
+	}
+	return transitions;
+}
+const NON_DOMAIN_SCOPES$1 = new Set(["auth", "document"]);
+function highestReducerVersion(reducers) {
+	const keys = Object.keys(reducers).map(Number);
+	if (keys.length === 0) throw new Error("VersionedReplayConfig.reducers must not be empty");
+	return Math.max(...keys);
+}
+/**
+* Version-aware document replay. Replays a versioned document through per-version
+* reducers, applying upgrade transitions at segment boundaries.
+*
+* Algorithm (D5):
+*   a. Build spine from operations["document"]. Empty spine or no upgrades → legacy fallback.
+*   b. Collect UPGRADE_DOCUMENT ops from the spine.
+*   c. Seed state from the creation upgrade (fromVersion===0). Missing seed with validated
+*      upgrades throws; otherwise falls back to legacy.
+*   d. Identify validated upgrades (fromVersion > 0, version increases). Compute per-scope
+*      boundaries using revision snapshot (preferred) or timestamp fallback.
+*   e. Loop over version segments, replaying each scope's ops through the matching reducer,
+*      then applying the upgrade transition before the next segment.
+*   f. Set header.revision["document"], verify per-scope hashes against state at op-time
+*      (not post-upgrade state) when checkHashes is false, and map timestamps from input.
+*
+* operations must include ALL scopes (document scope is NOT stripped).
+* reuseOperationResultingState is ignored by this function — zip operations never carry
+* resultingState.
+*/
+function replayDocumentVersioned(initialState, operations, config, header, dispatch, options) {
+	const { checkHashes = true, skipIndexValidation } = options || {};
+	const protocolVersion = header.protocolVersions?.["base-reducer"] ?? 1;
+	const spine = (operations["document"] ?? []).slice().sort((a, b) => a.index - b.index);
+	const upgrades = spine.filter((op) => op.action.type === "UPGRADE_DOCUMENT");
+	const legacyFallback = () => {
+		const domainOps = Object.fromEntries(Object.entries(operations).filter(([s]) => !NON_DOMAIN_SCOPES$1.has(s)));
+		const latestVersion = highestReducerVersion(config.reducers);
+		const reducer = config.reducers[latestVersion];
+		return {
+			...replayDocument(initialState, domainOps, reducer, header, dispatch, {}, options),
+			operations
+		};
+	};
+	if (spine.length === 0 || upgrades.length === 0) return legacyFallback();
+	const seedOp = upgrades[0];
+	if (!seedOp) return legacyFallback();
+	const seedAction = seedOp.action;
+	if (seedAction.input.fromVersion !== 0) return legacyFallback();
+	const seedInput = seedAction.input;
+	const seedState = seedInput.initialState ?? seedInput.state;
+	if (!seedState) {
+		const validatedUpgradeCount = upgrades.filter((op) => {
+			const a = op.action;
+			return a.input.fromVersion > 0 && a.input.fromVersion < a.input.toVersion;
+		}).length;
+		if (validatedUpgradeCount > 0) throw new Error(`Cannot reconstruct versioned history: the creation UPGRADE_DOCUMENT operation carries no initialState, but the document has ${validatedUpgradeCount} version-changing upgrade(s) recorded after creation. Pre-migration states cannot be reconstructed without the seeded initialState.`);
+		return legacyFallback();
+	}
+	const startVersion = seedAction.input.toVersion;
+	const validatedUpgrades = upgrades.filter((op) => {
+		const a = op.action;
+		return a.input.fromVersion > 0 && a.input.fromVersion < a.input.toVersion;
+	});
+	const domainScopes = Object.keys(operations).filter((s) => !NON_DOMAIN_SCOPES$1.has(s));
+	const scopeOps = {};
+	for (const s of domainScopes) scopeOps[s] = (operations[s] ?? []).slice().sort((a, b) => a.index - b.index);
+	const boundaries = validatedUpgrades.map((upgradeOp) => {
+		const revisionSnapshot = upgradeOp.action.input.revision;
+		const upgradeTimestamp = upgradeOp.timestampUtcMs;
+		const boundary = {};
+		for (const s of domainScopes) {
+			const ops = scopeOps[s] ?? [];
+			if (revisionSnapshot !== void 0) {
+				const rev = revisionSnapshot[s] ?? 0;
+				let b = 0;
+				for (let j = 0; j < ops.length; j++) if ((ops[j]?.index ?? 0) < rev) b = j + 1;
+				boundary[s] = b;
+			} else {
+				let b = ops.length;
+				for (let j = 0; j < ops.length; j++) if ((ops[j]?.timestampUtcMs ?? "") >= upgradeTimestamp) {
+					b = j;
+					break;
+				}
+				boundary[s] = b;
+			}
+		}
+		return boundary;
+	});
+	for (let i = 1; i < boundaries.length; i++) for (const s of domainScopes) {
+		const prev = boundaries[i - 1]?.[s] ?? 0;
+		const curr = boundaries[i]?.[s] ?? 0;
+		if (boundaries[i]) boundaries[i][s] = Math.max(prev, curr);
+	}
+	const allScopes = new Set([
+		...Object.keys(operations),
+		"global",
+		"local"
+	]);
+	const initialOperations = {};
+	for (const s of allScopes) initialOperations[s] = [];
+	let document = {
+		header,
+		state: seedState,
+		initialState: seedState,
+		operations: initialOperations,
+		clipboard: []
+	};
+	let currentVersion = startVersion;
+	const segmentEndHashPerScope = /* @__PURE__ */ new Map();
+	for (let k = 0; k <= validatedUpgrades.length; k++) {
+		const reducer = config.reducers[currentVersion];
+		if (!reducer) {
+			const available = Object.keys(config.reducers).join(", ");
+			throw new Error(`No reducer registered for document version ${currentVersion}. Available versions: ${available}`);
+		}
+		for (const s of domainScopes) {
+			const ops = scopeOps[s] ?? [];
+			const segStart = k === 0 ? 0 : boundaries[k - 1]?.[s] ?? 0;
+			const segEnd = k < validatedUpgrades.length ? boundaries[k]?.[s] ?? ops.length : ops.length;
+			const segOps = ops.slice(segStart, segEnd);
+			for (const op of segOps) {
+				document = reducer(document, op.action, dispatch, {
+					ignoreSkipOperations: true,
+					checkHashes,
+					skipIndexValidation,
+					replayOptions: { operation: op },
+					protocolVersion
+				});
+				segmentEndHashPerScope.set(s, hashDocumentStateForScope(document, s));
+			}
+		}
+		const prevUpgradeSpineIdx = k === 0 ? -1 : spine.indexOf(validatedUpgrades[k - 1]);
+		const nextUpgradeSpineIdx = k < validatedUpgrades.length ? spine.indexOf(validatedUpgrades[k]) : spine.length;
+		for (let si = prevUpgradeSpineIdx + 1; si < nextUpgradeSpineIdx; si++) {
+			const spineOp = spine[si];
+			if (!spineOp) continue;
+			const spineActionType = spineOp.action.type;
+			if (spineActionType === "CREATE_DOCUMENT" || spineActionType === "UPGRADE_DOCUMENT") continue;
+			if (spineActionType === "DELETE_DOCUMENT") document = applyDeleteDocumentAction(document, spineOp.action);
+			else document = reducer(document, spineOp.action, dispatch, {
+				ignoreSkipOperations: true,
+				checkHashes,
+				skipIndexValidation,
+				replayOptions: { operation: spineOp },
+				protocolVersion
+			});
+		}
+		if (k < validatedUpgrades.length) {
+			const upgradeAction = validatedUpgrades[k].action;
+			const fromVer = upgradeAction.input.fromVersion;
+			const toVer = upgradeAction.input.toVersion;
+			const transitions = computeUpgradeTransitions(config.upgradeManifest, fromVer, toVer);
+			document = applyUpgradeDocumentAction(document, upgradeAction, transitions);
+			currentVersion = toVer;
+		}
+	}
+	const lastSpineOp = spine.at(-1);
+	if (lastSpineOp !== void 0 && validatedUpgrades.length > 0) document = {
+		...document,
+		header: {
+			...document.header,
+			revision: {
+				...document.header.revision,
+				document: lastSpineOp.index + 1
+			}
+		}
+	};
+	if (!checkHashes) {
+		const allReplayedOps = domainScopes.flatMap((s) => scopeOps[s] ?? []);
+		for (const scope of Object.keys(document.state)) {
+			const capturedHash = segmentEndHashPerScope.get(scope);
+			const scopeHash = capturedHash !== void 0 ? capturedHash : hashDocumentStateForScope(document, scope);
+			for (let i = allReplayedOps.length - 1; i >= 0; i--) {
+				const operation = allReplayedOps[i];
+				if (!operation || operation.action.scope !== scope) continue;
+				if (operation.hash !== scopeHash) throw new HashMismatchError(scope, document, operation);
+				else break;
+			}
+		}
+	}
+	const allResultScopes = new Set([
+		...Object.keys(document.operations),
+		...Object.keys(operations),
+		"global",
+		"local"
+	]);
+	allResultScopes.delete("document");
+	const resultOperations = {};
+	for (const s of allResultScopes) resultOperations[s] = (document.operations[s] ?? []).map((op, index) => ({
+		...op,
+		timestamp: operations[s]?.[index]?.timestampUtcMs ?? op.timestampUtcMs
+	}));
+	const lastModified = header.lastModifiedAtUtcIso ? header.lastModifiedAtUtcIso : Object.values(resultOperations).reduce((acc, curr) => {
+		if (!curr) return acc;
+		const last = curr.at(-1);
+		if (last && last.timestampUtcMs > acc) return last.timestampUtcMs;
+		return acc;
+	}, document.header.lastModifiedAtUtcIso);
+	return {
+		...document,
+		header: {
+			...document.header,
+			lastModifiedAtUtcIso: lastModified
+		},
+		operations: {
+			...operations,
+			...resultOperations
+		}
+	};
+}
 const NON_DOMAIN_SCOPES = new Set(["auth", "document"]);
 function zipAsync(data) {
 	return new Promise((resolve, reject) => {
@@ -5858,7 +6147,7 @@ function readEntry(files, name) {
 	if (!entry) throw new Error(`${name} not found in document zip`);
 	return strFromU8(entry);
 }
-async function loadFromZipData(data, reducer, options) {
+async function parseZipData(data) {
 	const files = await unzipAsync(data);
 	if (!files["state.json"]) throw new Error("Initial state not found");
 	const initialState = JSON.parse(readEntry(files, "state.json"));
@@ -5871,14 +6160,32 @@ async function loadFromZipData(data, reducer, options) {
 		const errorMessages = operationsError.map((err) => err.message);
 		throw new Error(errorMessages.join("\n"));
 	}
+	return {
+		initialState,
+		header,
+		clearedOperations
+	};
+}
+async function loadFromZipData(data, reducer, options) {
+	const { initialState, header, clearedOperations } = await parseZipData(data);
 	return {
 		...replayDocument(initialState, Object.fromEntries(Object.entries(clearedOperations).filter(([scope]) => !NON_DOMAIN_SCOPES.has(scope))), reducer, header, void 0, {}, options),
 		operations: clearedOperations
 	};
 }
+async function loadFromZipDataVersioned(data, config, options) {
+	const { initialState, header, clearedOperations } = await parseZipData(data);
+	return {
+		...replayDocumentVersioned(initialState, clearedOperations, config, header, void 0, options),
+		operations: clearedOperations
+	};
+}
 async function baseLoadFromInput(input, reducer, options) {
 	return loadFromZipData(await toUint8Array(input), reducer, options);
 }
+async function baseLoadFromInputVersioned(input, config, options) {
+	return loadFromZipDataVersioned(await toUint8Array(input), config, options);
+}
 const documentModelLoadFromInput = (input) => {
 	return baseLoadFromInput(input, documentModelReducer);
 };
@@ -7053,6 +7360,6 @@ const driveDocumentModelModule = {
 	}
 };
 //#endregion
-export { replayDocument as A, setOperationDescription as B, defaultBaseState as C, documentModelDocumentType as D, deleteOperationError as E, setModelExtension as F, undo as G, setOperationName as H, setModelId as I, validateStateSchemaName as J, validateInitialState as K, setModelName as L, setAuthorWebsite as M, setInitialState as N, isDocumentAction as O, setModelDescription as P, setModuleName as R, createZip as S, deleteOperation as T, setOperationSchema as U, setOperationErrorName as V, setStateSchema as W, generateId as Y, baseSaveToFileHandle as _, handleTargetNameCollisions as a, createReducer as b, moveNode as c, logger as d, addModule as f, baseLoadFromInput as g, baseCreateDocument as h, generateNodesCopy as i, setAuthorName as j, redo as k, updateNode as l, addOperationError as m, copyNode as n, isFileNode as o, addOperation as p, validateModules as q, driveDocumentModelModule as r, isFolderNode as s, addFolder as t, documentModelDocumentModelModule as u, buildSignedAction as v, deleteModule as w, createState as x, createPresignedHeader as y, setName as z };
+export { redo as A, setName as B, createZip as C, deleteOperationError as D, deleteOperation as E, setModelDescription as F, setStateSchema as G, setOperationErrorName as H, setModelExtension as I, validateModules as J, undo as K, setModelId as L, setAuthorName as M, setAuthorWebsite as N, documentModelDocumentType as O, setInitialState as P, setModelName as R, createState as S, deleteModule as T, setOperationName as U, setOperationDescription as V, setOperationSchema as W, generateId as X, validateStateSchemaName as Y, baseLoadFromInputVersioned as _, handleTargetNameCollisions as a, createPresignedHeader as b, moveNode as c, logger as d, addModule as f, baseLoadFromInput as g, baseCreateDocument as h, generateNodesCopy as i, replayDocumentVersioned as j, isDocumentAction as k, updateNode as l, addOperationError as m, copyNode as n, isFileNode as o, addOperation as p, validateInitialState as q, driveDocumentModelModule as r, isFolderNode as s, addFolder as t, documentModelDocumentModelModule as u, baseSaveToFileHandle as v, defaultBaseState as w, createReducer as x, buildSignedAction as y, setModuleName as z };
 
-//# sourceMappingURL=document-drive-CDaY4aIj.js.map
+//# sourceMappingURL=document-drive-sTKoi6L4.js.map