@powerhousedao/reactor-drive 6.0.0-dev.253 → 6.0.0-dev.254

package/dist/index.js

@@ -0,0 +1,1228 @@
+import { baseCreateDocument, baseLoadFromInput, baseSaveToFileHandle, createPresignedHeader, createReducer, createState, defaultBaseState, generateId, isDocumentAction, replayDocument } from "@powerhousedao/shared/document-model";
+import { Migrator, sql } from "kysely";
+import { BaseReadModel, addRelationshipAction, createDocumentAction, removeRelationshipAction, upgradeDocumentAction } from "@powerhousedao/reactor";
+import { gql } from "graphql-tag";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/constants.ts
+const REACTOR_DRIVE_DOCUMENT_TYPE = "powerhouse/reactor-drive";
+const DRIVE_CHILD_RELATIONSHIP_TYPE = "drive/child";
+const REACTOR_DRIVE_FILE_EXTENSION = "phrd";
+//#endregion
+//#region src/actions.ts
+function setDriveNameAction(input) {
+	return {
+		id: generateId(),
+		type: "SET_DRIVE_NAME",
+		scope: "global",
+		timestampUtcMs: (/* @__PURE__ */ new Date()).toISOString(),
+		input
+	};
+}
+function setDriveIconAction(input) {
+	return {
+		id: generateId(),
+		type: "SET_DRIVE_ICON",
+		scope: "global",
+		timestampUtcMs: (/* @__PURE__ */ new Date()).toISOString(),
+		input
+	};
+}
+function setSharingTypeAction(input) {
+	return {
+		id: generateId(),
+		type: "SET_SHARING_TYPE",
+		scope: "local",
+		timestampUtcMs: (/* @__PURE__ */ new Date()).toISOString(),
+		input
+	};
+}
+function setAvailableOfflineAction(input) {
+	return {
+		id: generateId(),
+		type: "SET_AVAILABLE_OFFLINE",
+		scope: "local",
+		timestampUtcMs: (/* @__PURE__ */ new Date()).toISOString(),
+		input
+	};
+}
+function addFolderAction(input) {
+	return {
+		id: generateId(),
+		type: "ADD_FOLDER",
+		scope: "document",
+		timestampUtcMs: (/* @__PURE__ */ new Date()).toISOString(),
+		input
+	};
+}
+function updateFolderAction(input) {
+	return {
+		id: generateId(),
+		type: "UPDATE_FOLDER",
+		scope: "document",
+		timestampUtcMs: (/* @__PURE__ */ new Date()).toISOString(),
+		input
+	};
+}
+function removeFolderAction(input) {
+	return {
+		id: generateId(),
+		type: "REMOVE_FOLDER",
+		scope: "document",
+		timestampUtcMs: (/* @__PURE__ */ new Date()).toISOString(),
+		input
+	};
+}
+const reactorDriveActions = {
+	setDriveName: setDriveNameAction,
+	setDriveIcon: setDriveIconAction,
+	setSharingType: setSharingTypeAction,
+	setAvailableOffline: setAvailableOfflineAction,
+	addFolder: addFolderAction,
+	updateFolder: updateFolderAction,
+	removeFolder: removeFolderAction
+};
+//#endregion
+//#region src/reducer/drive.ts
+const reactorDriveStateReducer = (state, action) => {
+	if (isDocumentAction(action)) return state;
+	const typedAction = action;
+	switch (typedAction.type) {
+		case "SET_DRIVE_NAME": {
+			const input = typedAction.input;
+			state.global.name = input.name;
+			return state;
+		}
+		case "SET_DRIVE_ICON": {
+			const input = typedAction.input;
+			state.global.icon = input.icon;
+			return state;
+		}
+		case "SET_SHARING_TYPE": {
+			const input = typedAction.input;
+			state.local.sharingType = input.sharingType;
+			return state;
+		}
+		case "SET_AVAILABLE_OFFLINE": {
+			const input = typedAction.input;
+			state.local.availableOffline = input.availableOffline;
+			return state;
+		}
+		case "ADD_FOLDER":
+		case "UPDATE_FOLDER":
+		case "REMOVE_FOLDER": return state;
+		default: return state;
+	}
+};
+//#endregion
+//#region src/module.ts
+const initialGlobalState = {
+	name: "",
+	icon: null
+};
+const initialLocalState = {
+	sharingType: "private",
+	availableOffline: false
+};
+const reactorDriveCreateState = (state) => {
+	return {
+		...defaultBaseState(),
+		global: {
+			...initialGlobalState,
+			...state?.global
+		},
+		local: {
+			...initialLocalState,
+			...state?.local
+		}
+	};
+};
+const reactorDriveCreateDocument = (state) => {
+	const document = baseCreateDocument(reactorDriveCreateState, state);
+	document.header.documentType = REACTOR_DRIVE_DOCUMENT_TYPE;
+	return document;
+};
+const reactorDriveSaveToFileHandle = (document, input) => {
+	return baseSaveToFileHandle(document, input);
+};
+const reactorDriveLoadFromInput = (input) => {
+	return baseLoadFromInput(input, reactorDriveDocumentReducer);
+};
+const isReactorDriveState = (state) => {
+	return typeof state === "object" && state !== null && "global" in state && "local" in state;
+};
+const assertIsReactorDriveState = (state) => {
+	if (!isReactorDriveState(state)) throw new Error("Not a reactor-drive state");
+};
+const isReactorDriveDocument = (document) => {
+	return typeof document === "object" && document !== null && "header" in document && document.header.documentType === "powerhouse/reactor-drive";
+};
+const assertIsReactorDriveDocument = (document) => {
+	if (!isReactorDriveDocument(document)) throw new Error("Not a reactor-drive document");
+};
+const reactorDriveDocumentReducer = createReducer(reactorDriveStateReducer);
+const reactorDriveDocumentGlobalState = {
+	id: REACTOR_DRIVE_DOCUMENT_TYPE,
+	name: "ReactorDrive",
+	extension: REACTOR_DRIVE_FILE_EXTENSION,
+	description: "",
+	author: {
+		name: "Powerhouse Inc",
+		website: "https://www.powerhouse.inc/"
+	},
+	specifications: [{
+		version: 1,
+		changeLog: [],
+		state: {
+			global: {
+				schema: "type ReactorDriveState {\n  name: String!\n  icon: String\n}",
+				initialValue: JSON.stringify(JSON.stringify(initialGlobalState)),
+				examples: []
+			},
+			local: {
+				schema: "type ReactorDriveLocalState {\n  sharingType: String!\n  availableOffline: Boolean!\n}",
+				initialValue: JSON.stringify(JSON.stringify(initialLocalState)),
+				examples: []
+			}
+		},
+		modules: [{
+			id: "reactor-drive/base-operations",
+			name: "base_operations",
+			description: "",
+			operations: [
+				{
+					id: "SET_DRIVE_NAME",
+					name: "SET_DRIVE_NAME",
+					description: "",
+					schema: "input SetDriveNameInput { name: String! }",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "global"
+				},
+				{
+					id: "SET_DRIVE_ICON",
+					name: "SET_DRIVE_ICON",
+					description: "",
+					schema: "input SetDriveIconInput { icon: String }",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "global"
+				},
+				{
+					id: "SET_SHARING_TYPE",
+					name: "SET_SHARING_TYPE",
+					description: "",
+					schema: "input SetSharingTypeInput { sharingType: String! }",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "local"
+				},
+				{
+					id: "SET_AVAILABLE_OFFLINE",
+					name: "SET_AVAILABLE_OFFLINE",
+					description: "",
+					schema: "input SetAvailableOfflineInput { availableOffline: Boolean! }",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "local"
+				},
+				{
+					id: "ADD_FOLDER",
+					name: "ADD_FOLDER",
+					description: "",
+					schema: "input AddFolderInput { folderId: String! parentFolderId: String name: String! }",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "document"
+				},
+				{
+					id: "UPDATE_FOLDER",
+					name: "UPDATE_FOLDER",
+					description: "",
+					schema: "input UpdateFolderInput { folderId: String! name: String parentFolderId: String }",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "document"
+				},
+				{
+					id: "REMOVE_FOLDER",
+					name: "REMOVE_FOLDER",
+					description: "",
+					schema: "input RemoveFolderInput { folderId: String! }",
+					template: "",
+					reducer: "",
+					errors: [],
+					examples: [],
+					scope: "document"
+				}
+			]
+		}]
+	}]
+};
+const reactorDriveDocumentModelModule = {
+	actions: reactorDriveActions,
+	reducer: reactorDriveDocumentReducer,
+	documentModel: createState(defaultBaseState(), reactorDriveDocumentGlobalState),
+	utils: {
+		fileExtension: REACTOR_DRIVE_FILE_EXTENSION,
+		createState: reactorDriveCreateState,
+		createDocument: reactorDriveCreateDocument,
+		loadFromInput: reactorDriveLoadFromInput,
+		saveToFileHandle: reactorDriveSaveToFileHandle,
+		isStateOfType: isReactorDriveState,
+		assertIsStateOfType: assertIsReactorDriveState,
+		isDocumentOfType: isReactorDriveDocument,
+		assertIsDocumentOfType: assertIsReactorDriveDocument
+	}
+};
+//#endregion
+//#region src/schema/migrations/0001_drive_node.ts
+var _0001_drive_node_exports = /* @__PURE__ */ __exportAll({
+	down: () => down$1,
+	up: () => up$1
+});
+async function up$1(db) {
+	await db.schema.createTable("DriveNode").ifNotExists().addColumn("driveId", "text", (col) => col.notNull()).addColumn("id", "text", (col) => col.notNull()).addColumn("kind", "text", (col) => col.notNull()).addColumn("name", "text", (col) => col.notNull()).addColumn("requestedName", "text", (col) => col.notNull()).addColumn("parentFolder", "text").addColumn("documentType", "text").addColumn("createdAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("updatedAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addPrimaryKeyConstraint("pk_drive_node", ["driveId", "id"]).addCheckConstraint("chk_drive_node_document_type", sql`(kind = 'file' AND "documentType" IS NOT NULL) OR (kind = 'folder' AND "documentType" IS NULL)`).execute();
+	await db.schema.createIndex("idx_drive_node_parent_name").ifNotExists().on("DriveNode").columns([
+		"driveId",
+		"parentFolder",
+		"name"
+	]).execute();
+	await db.schema.createIndex("idx_drive_node_parent_kind_id").ifNotExists().on("DriveNode").columns([
+		"driveId",
+		"parentFolder",
+		"kind",
+		"id"
+	]).execute();
+}
+async function down$1(db) {
+	await db.schema.dropTable("DriveNode").execute();
+}
+//#endregion
+//#region src/schema/migrations/0002_document_name.ts
+var _0002_document_name_exports = /* @__PURE__ */ __exportAll({
+	down: () => down,
+	up: () => up
+});
+async function up(db) {
+	await db.schema.createTable("DocumentName").ifNotExists().addColumn("docId", "text", (col) => col.primaryKey()).addColumn("name", "text", (col) => col.notNull()).addColumn("updatedAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
+}
+async function down(db) {
+	await db.schema.dropTable("DocumentName").execute();
+}
+//#endregion
+//#region src/schema/migrations/migrator.ts
+const migrations = {
+	"0001_drive_node": _0001_drive_node_exports,
+	"0002_document_name": _0002_document_name_exports
+};
+const REACTOR_DRIVE_MIGRATION_TABLE = "kysely_migration_reactor_drive";
+const REACTOR_DRIVE_MIGRATION_LOCK_TABLE = "kysely_migration_reactor_drive_lock";
+var ProgrammaticMigrationProvider = class {
+	getMigrations() {
+		return Promise.resolve(migrations);
+	}
+};
+async function runReactorDriveMigrations(db, schema) {
+	try {
+		await sql`CREATE SCHEMA IF NOT EXISTS ${sql.id(schema)}`.execute(db);
+	} catch (error) {
+		return {
+			success: false,
+			migrationsExecuted: [],
+			error: error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to create schema")
+		};
+	}
+	const migrator = new Migrator({
+		db: db.withSchema(schema),
+		provider: new ProgrammaticMigrationProvider(),
+		migrationTableSchema: schema,
+		migrationTableName: REACTOR_DRIVE_MIGRATION_TABLE,
+		migrationLockTableName: REACTOR_DRIVE_MIGRATION_LOCK_TABLE
+	});
+	let error;
+	let results;
+	try {
+		const result = await migrator.migrateToLatest();
+		error = result.error;
+		results = result.results;
+	} catch (e) {
+		error = e;
+		results = [];
+	}
+	const migrationsExecuted = results?.map((result) => result.migrationName) ?? [];
+	if (error) return {
+		success: false,
+		migrationsExecuted,
+		error: error instanceof Error ? error : /* @__PURE__ */ new Error("Unknown migration error")
+	};
+	return {
+		success: true,
+		migrationsExecuted
+	};
+}
+async function getReactorDriveMigrationStatus(db, schema) {
+	return await new Migrator({
+		db: db.withSchema(schema),
+		provider: new ProgrammaticMigrationProvider(),
+		migrationTableSchema: schema,
+		migrationTableName: REACTOR_DRIVE_MIGRATION_TABLE,
+		migrationLockTableName: REACTOR_DRIVE_MIGRATION_LOCK_TABLE
+	}).getMigrations();
+}
+//#endregion
+//#region src/processors/utils/collisions.ts
+/**
+* Deterministic per-folder name collision rule. Given a desired name and the
+* set of names already taken by siblings, returns the next available name as
+* `requested`, `requested (2)`, `requested (3)`, etc.
+*
+* The rule matches the legacy document-drive module so that migration from
+* the legacy state produces stable suffixes.
+*/
+function resolveCollision(requested, takenNames) {
+	const taken = /* @__PURE__ */ new Set();
+	for (const name of takenNames) taken.add(name);
+	if (!taken.has(requested)) return requested;
+	let suffix = 2;
+	while (taken.has(`${requested} (${suffix})`)) suffix += 1;
+	return `${requested} (${suffix})`;
+}
+//#endregion
+//#region src/processors/node-processor.ts
+const NAME_ACTION_TYPES = new Set([
+	"CREATE_DOCUMENT",
+	"UPGRADE_DOCUMENT",
+	"SET_NAME"
+]);
+const STRUCTURE_ACTION_TYPES = new Set([
+	"ADD_RELATIONSHIP",
+	"REMOVE_RELATIONSHIP",
+	"ADD_FOLDER",
+	"UPDATE_FOLDER",
+	"REMOVE_FOLDER"
+]);
+var NodeProcessor = class extends BaseReadModel {
+	driveDb;
+	baseDb;
+	schema;
+	constructor(baseDb, schema, operationIndex, writeCache, consistencyTracker) {
+		const scopedDb = baseDb.withSchema(schema);
+		super(scopedDb, operationIndex, writeCache, consistencyTracker, {
+			readModelId: "reactor-drive-node-processor",
+			rebuildStateOnInit: false
+		});
+		this.driveDb = scopedDb;
+		this.baseDb = baseDb;
+		this.schema = schema;
+	}
+	async init() {
+		const result = await runReactorDriveMigrations(this.baseDb, this.schema);
+		if (!result.success && result.error) throw new Error(`Reactor drive migrations failed: ${result.error.message}`);
+		await super.init();
+	}
+	async commitOperations(items) {
+		await this.driveDb.transaction().execute(async (trx) => {
+			for (const item of items) {
+				const actionType = item.operation.action.type;
+				if (NAME_ACTION_TYPES.has(actionType)) {
+					await this.applyNameOperation(trx, item);
+					continue;
+				}
+				if (STRUCTURE_ACTION_TYPES.has(actionType)) {
+					await this.applyStructureOperation(trx, item);
+					continue;
+				}
+				if (actionType === "DELETE_DOCUMENT") await this.applyDeleteDocument(trx, item);
+			}
+		});
+	}
+	async applyNameOperation(trx, item) {
+		const action = item.operation.action;
+		const docId = item.context.documentId;
+		let name;
+		if (action.type === "CREATE_DOCUMENT") name = action.input.name;
+		else if (action.type === "UPGRADE_DOCUMENT") name = (action.input.initialState ?? {}).header?.name;
+		else if (action.type === "SET_NAME") name = action.input.name;
+		if (name === void 0) return;
+		await this.upsertDocumentName(trx, docId, name);
+		const linkedRows = await trx.selectFrom("DriveNode").selectAll().where("id", "=", docId).where("kind", "=", "file").execute();
+		for (const row of linkedRows) {
+			const resolved = await this.resolveSiblingName(trx, row.driveId, row.parentFolder, name, docId);
+			await trx.updateTable("DriveNode").set({
+				name: resolved,
+				requestedName: name,
+				updatedAt: /* @__PURE__ */ new Date()
+			}).where("driveId", "=", row.driveId).where("id", "=", docId).execute();
+		}
+	}
+	async applyStructureOperation(trx, item) {
+		if (item.context.documentType !== "powerhouse/reactor-drive") return;
+		const action = item.operation.action;
+		const driveId = item.context.documentId;
+		if (action.type === "ADD_RELATIONSHIP") {
+			const input = action.input;
+			if (input.relationshipType !== "drive/child") return;
+			await this.handleAddFileRelationship(trx, driveId, input);
+			return;
+		}
+		if (action.type === "REMOVE_RELATIONSHIP") {
+			const input = action.input;
+			if (input.relationshipType !== "drive/child") return;
+			await trx.deleteFrom("DriveNode").where("driveId", "=", driveId).where("id", "=", input.targetId).execute();
+			return;
+		}
+		if (action.type === "ADD_FOLDER") {
+			await this.handleAddFolder(trx, driveId, action.input);
+			return;
+		}
+		if (action.type === "UPDATE_FOLDER") {
+			await this.handleUpdateFolder(trx, driveId, action.input);
+			return;
+		}
+		if (action.type === "REMOVE_FOLDER") {
+			const input = action.input;
+			await trx.deleteFrom("DriveNode").where("driveId", "=", driveId).where("id", "=", input.folderId).execute();
+		}
+	}
+	async applyDeleteDocument(trx, item) {
+		const docId = item.operation.action.input.documentId || item.context.documentId;
+		await trx.deleteFrom("DriveNode").where("id", "=", docId).execute();
+		await trx.deleteFrom("DocumentName").where("docId", "=", docId).execute();
+	}
+	async handleAddFileRelationship(trx, driveId, input) {
+		const metadata = this.parseFileMetadata(input);
+		const parentFolder = metadata.parentFolderId ?? null;
+		const documentType = metadata.documentType;
+		const requestedName = await this.lookupDocumentName(trx, input.targetId) ?? "";
+		const resolved = await this.resolveSiblingName(trx, driveId, parentFolder, requestedName, input.targetId);
+		await trx.insertInto("DriveNode").values({
+			driveId,
+			id: input.targetId,
+			kind: "file",
+			name: resolved,
+			requestedName,
+			parentFolder,
+			documentType
+		}).onConflict((oc) => oc.columns(["driveId", "id"]).doUpdateSet({
+			parentFolder,
+			name: resolved,
+			requestedName,
+			kind: "file",
+			documentType,
+			updatedAt: /* @__PURE__ */ new Date()
+		})).execute();
+	}
+	async handleAddFolder(trx, driveId, input) {
+		const parentFolder = input.parentFolderId ?? null;
+		const resolved = await this.resolveSiblingName(trx, driveId, parentFolder, input.name, input.folderId);
+		await trx.insertInto("DriveNode").values({
+			driveId,
+			id: input.folderId,
+			kind: "folder",
+			name: resolved,
+			requestedName: input.name,
+			parentFolder,
+			documentType: null
+		}).onConflict((oc) => oc.columns(["driveId", "id"]).doUpdateSet({
+			parentFolder,
+			name: resolved,
+			requestedName: input.name,
+			kind: "folder",
+			documentType: null,
+			updatedAt: /* @__PURE__ */ new Date()
+		})).execute();
+	}
+	async handleUpdateFolder(trx, driveId, input) {
+		const row = await trx.selectFrom("DriveNode").selectAll().where("driveId", "=", driveId).where("id", "=", input.folderId).executeTakeFirst();
+		if (!row) return;
+		const nextParentFolder = input.parentFolderId === void 0 ? row.parentFolder : input.parentFolderId ?? null;
+		const nextRequestedName = typeof input.name === "string" ? input.name : row.requestedName;
+		const resolved = await this.resolveSiblingName(trx, driveId, nextParentFolder, nextRequestedName, input.folderId);
+		await trx.updateTable("DriveNode").set({
+			parentFolder: nextParentFolder,
+			name: resolved,
+			requestedName: nextRequestedName,
+			updatedAt: /* @__PURE__ */ new Date()
+		}).where("driveId", "=", driveId).where("id", "=", input.folderId).execute();
+	}
+	async resolveSiblingName(trx, driveId, parentFolder, requested, excludeId) {
+		let query = trx.selectFrom("DriveNode").select("name").where("driveId", "=", driveId).where("id", "!=", excludeId);
+		query = parentFolder === null ? query.where("parentFolder", "is", null) : query.where("parentFolder", "=", parentFolder);
+		return resolveCollision(requested, (await query.execute()).map((r) => r.name));
+	}
+	async lookupDocumentName(trx, docId) {
+		return (await trx.selectFrom("DocumentName").select("name").where("docId", "=", docId).executeTakeFirst())?.name;
+	}
+	parseFileMetadata(input) {
+		const metadata = input.metadata;
+		if (!metadata || typeof metadata !== "object" || metadata.kind !== "file" || typeof metadata.documentType !== "string") throw new Error(`ADD_RELATIONSHIP for target ${input.targetId}: missing or invalid drive/child file metadata (expected { kind: "file", parentFolderId, documentType })`);
+		const typed = metadata;
+		return {
+			kind: "file",
+			parentFolderId: typed.parentFolderId ?? null,
+			documentType: typed.documentType
+		};
+	}
+	async upsertDocumentName(trx, docId, name) {
+		await trx.insertInto("DocumentName").values({
+			docId,
+			name
+		}).onConflict((oc) => oc.column("docId").doUpdateSet({
+			name,
+			updatedAt: /* @__PURE__ */ new Date()
+		})).execute();
+	}
+};
+//#endregion
+//#region src/read-model/drive-node-view.ts
+const DEFAULT_LIMIT$1 = 100;
+function parseListChildrenPaging(paging) {
+	if (paging === void 0) return {
+		limit: DEFAULT_LIMIT$1,
+		cursor: null
+	};
+	if (!Number.isInteger(paging.limit) || paging.limit < 1) throw new Error(`Invalid paging limit: ${String(paging.limit)} (must be an integer >= 1)`);
+	if (paging.cursor === "") return {
+		limit: paging.limit,
+		cursor: null
+	};
+	return {
+		limit: paging.limit,
+		cursor: decodeKeysetCursor(paging.cursor)
+	};
+}
+function encodeKeysetCursor(createdAt, id) {
+	return globalThis.btoa(JSON.stringify({
+		createdAt: createdAt.toISOString(),
+		id
+	}));
+}
+function decodeKeysetCursor(cursor) {
+	let decoded;
+	try {
+		decoded = globalThis.atob(cursor);
+	} catch {
+		throw new Error(`Invalid paging cursor: ${JSON.stringify(cursor)} (must be a keyset cursor returned by a prior page)`);
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(decoded);
+	} catch {
+		throw new Error(`Invalid paging cursor: ${JSON.stringify(cursor)} (must be a keyset cursor returned by a prior page)`);
+	}
+	if (parsed === null || typeof parsed !== "object" || typeof parsed.createdAt !== "string" || typeof parsed.id !== "string") throw new Error(`Invalid paging cursor: ${JSON.stringify(cursor)} (must be a keyset cursor returned by a prior page)`);
+	const createdAt = new Date(parsed.createdAt);
+	if (Number.isNaN(createdAt.getTime())) throw new Error(`Invalid paging cursor: ${JSON.stringify(cursor)} (createdAt is not a valid timestamp)`);
+	return {
+		createdAt,
+		id: parsed.id
+	};
+}
+var DriveNodeView = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async getNode(driveId, nodeId) {
+		const row = await this.db.selectFrom("DriveNode").selectAll().where("driveId", "=", driveId).where("id", "=", nodeId).executeTakeFirst();
+		if (!row) return void 0;
+		return rowToNode(row);
+	}
+	async listChildren(driveId, parentFolder, paging) {
+		const { limit, cursor } = parseListChildrenPaging(paging);
+		let query = this.db.selectFrom("DriveNode").selectAll().where("driveId", "=", driveId);
+		if (parentFolder === null) query = query.where("parentFolder", "is", null);
+		else if (parentFolder !== void 0) query = query.where("parentFolder", "=", parentFolder);
+		if (cursor !== null) query = query.where((eb) => eb(eb.refTuple("createdAt", "id"), ">", eb.tuple(cursor.createdAt, cursor.id)));
+		const rows = await query.orderBy("createdAt", "asc").orderBy("id", "asc").limit(limit + 1).execute();
+		const hasMore = rows.length > limit;
+		const sliced = hasMore ? rows.slice(0, limit) : rows;
+		const last = sliced[sliced.length - 1];
+		return {
+			results: sliced.map(rowToNode),
+			options: {
+				cursor: paging?.cursor ?? "",
+				limit
+			},
+			nextCursor: hasMore ? encodeKeysetCursor(last.createdAt, last.id) : void 0
+		};
+	}
+	async listAll(driveId) {
+		return (await this.db.selectFrom("DriveNode").selectAll().where("driveId", "=", driveId).orderBy("createdAt", "asc").orderBy("id", "asc").execute()).map(rowToNode);
+	}
+	async getDescendants(driveId, root) {
+		return (await this.db.withRecursive("descendants", (qb) => qb.selectFrom("DriveNode").select([
+			"driveId",
+			"id",
+			"kind",
+			"name",
+			"requestedName",
+			"parentFolder",
+			"documentType",
+			"createdAt"
+		]).where("driveId", "=", driveId).where("id", "=", root).unionAll(qb.selectFrom("DriveNode").innerJoin("descendants", "DriveNode.parentFolder", "descendants.id").where("DriveNode.driveId", "=", driveId).select([
+			"DriveNode.driveId",
+			"DriveNode.id",
+			"DriveNode.kind",
+			"DriveNode.name",
+			"DriveNode.requestedName",
+			"DriveNode.parentFolder",
+			"DriveNode.documentType",
+			"DriveNode.createdAt"
+		]))).selectFrom("descendants").select([
+			"driveId",
+			"id",
+			"kind",
+			"name",
+			"requestedName",
+			"parentFolder",
+			"documentType"
+		]).orderBy("createdAt", "asc").orderBy("id", "asc").execute()).map(rowToNode);
+	}
+};
+function rowToNode(row) {
+	if (row.kind === "file") {
+		if (row.documentType === null) throw new Error(`DriveNode ${row.driveId}/${row.id}: file row has null documentType, which violates the schema CHECK constraint`);
+		return {
+			kind: "file",
+			id: row.id,
+			driveId: row.driveId,
+			parentFolder: row.parentFolder,
+			name: row.name,
+			documentType: row.documentType
+		};
+	}
+	return {
+		kind: "folder",
+		id: row.id,
+		driveId: row.driveId,
+		parentFolder: row.parentFolder,
+		name: row.name
+	};
+}
+//#endregion
+//#region src/client/reactor-drive-client.ts
+/**
+* Implementation of {@link IDriveClient} backed by the reactor's relationship
+* primitives and the drive-scoped folder actions. Folder structure lives in
+* the operation log (ADD_FOLDER/UPDATE_FOLDER/REMOVE_FOLDER + ADD_RELATIONSHIP
+* for files) and is materialised by `NodeProcessor` into the `DriveNode`
+* table consumed via {@link IDriveReadModel}.
+*/
+var ReactorDriveClient = class {
+	reactor;
+	readModel;
+	constructor(args) {
+		this.reactor = args.reactor;
+		this.readModel = args.readModel;
+	}
+	async create(input, signal) {
+		const driveDoc = reactorDriveCreateDocument({ global: {
+			name: input.global.name,
+			icon: input.global.icon ?? null
+		} });
+		if (input.local) {
+			if (typeof input.local.sharingType === "string") driveDoc.state.local.sharingType = input.local.sharingType;
+			if (typeof input.local.availableOffline === "boolean") driveDoc.state.local.availableOffline = input.local.availableOffline;
+		}
+		if (input.preferredEditor) driveDoc.header.meta = {
+			...driveDoc.header.meta,
+			preferredEditor: input.preferredEditor
+		};
+		const created = await this.reactor.create(driveDoc, void 0, signal);
+		return this.toLegacyDriveDocument(created, created.header.id);
+	}
+	async addFile(driveIdentifier, document, parentFolder, signal) {
+		const documentId = document.header.id;
+		const createInput = {
+			model: document.header.documentType,
+			version: 0,
+			documentId,
+			signing: {
+				signature: documentId,
+				publicKey: document.header.sig.publicKey,
+				nonce: document.header.sig.nonce,
+				createdAtUtcIso: document.header.createdAtUtcIso,
+				documentType: document.header.documentType
+			},
+			slug: document.header.slug,
+			name: document.header.name,
+			branch: document.header.branch,
+			meta: document.header.meta,
+			protocolVersions: document.header.protocolVersions ?? { "base-reducer": 2 }
+		};
+		const metadata = {
+			kind: "file",
+			parentFolderId: parentFolder ?? null,
+			documentType: document.header.documentType
+		};
+		const request = { jobs: [{
+			key: "create",
+			documentId,
+			scope: "document",
+			branch: "main",
+			actions: [createDocumentAction(createInput), upgradeDocumentAction({
+				documentId,
+				model: document.header.documentType,
+				fromVersion: 0,
+				toVersion: document.state.document.version,
+				initialState: document.state
+			})],
+			dependsOn: []
+		}, {
+			key: "link",
+			documentId: driveIdentifier,
+			scope: "document",
+			branch: "main",
+			actions: [addRelationshipAction(driveIdentifier, documentId, DRIVE_CHILD_RELATIONSHIP_TYPE, metadata)],
+			dependsOn: ["create"]
+		}] };
+		await this.reactor.executeBatch(request, signal);
+		return this.reactor.get(documentId, void 0, signal);
+	}
+	async addFolder(driveIdentifier, name, parentFolder, signal) {
+		const folderId = generateId();
+		await this.reactor.execute(driveIdentifier, "main", [addFolderAction({
+			folderId,
+			parentFolderId: parentFolder ?? null,
+			name
+		})], signal);
+		return {
+			id: folderId,
+			kind: "folder",
+			name,
+			parentFolder: parentFolder ?? null
+		};
+	}
+	async removeNode(driveIdentifier, nodeId, signal) {
+		const node = await this.readModel.getNode(driveIdentifier, nodeId, signal);
+		if (!node) throw new Error(`Node ${nodeId} not found in drive ${driveIdentifier}`);
+		if (node.kind === "folder") {
+			const subtree = await this.readModel.getDescendants(driveIdentifier, nodeId, signal);
+			const fileDescendants = subtree.filter((n) => n.kind === "file");
+			const subFolders = subtree.filter((n) => n.kind === "folder").filter((f) => f.id !== nodeId);
+			const deepestFirstFolders = this.orderDeepestFirst(subFolders, nodeId);
+			const batch = [
+				...fileDescendants.map((f) => removeRelationshipAction(driveIdentifier, f.id, DRIVE_CHILD_RELATIONSHIP_TYPE)),
+				...deepestFirstFolders.map((f) => removeFolderAction({ folderId: f.id })),
+				removeFolderAction({ folderId: nodeId })
+			];
+			await this.reactor.execute(driveIdentifier, "main", batch, signal);
+			for (const file of fileDescendants) await this.reactor.deleteDocument(file.id, "cascade", signal);
+			return;
+		}
+		await this.reactor.execute(driveIdentifier, "main", [removeRelationshipAction(driveIdentifier, nodeId, DRIVE_CHILD_RELATIONSHIP_TYPE)], signal);
+		await this.reactor.deleteDocument(nodeId, void 0, signal);
+	}
+	async renameNode(driveIdentifier, nodeId, name, signal) {
+		const node = await this.readModel.getNode(driveIdentifier, nodeId, signal);
+		if (!node) throw new Error(`Node ${nodeId} not found in drive ${driveIdentifier}`);
+		if (node.kind === "file") await this.reactor.rename(nodeId, name, "main", signal);
+		else await this.reactor.execute(driveIdentifier, "main", [updateFolderAction({
+			folderId: nodeId,
+			name
+		})], signal);
+		const updated = await this.readModel.getNode(driveIdentifier, nodeId, signal);
+		if (!updated) throw new Error("Node missing from drive after rename");
+		return this.toLegacyNode(updated);
+	}
+	async setPreferredEditorOnNode(nodeId, preferredEditor, signal) {
+		return this.reactor.setPreferredEditor(nodeId, preferredEditor, "main", signal);
+	}
+	async moveNode(driveIdentifier, srcNodeId, targetParentFolderId, signal) {
+		const node = await this.readModel.getNode(driveIdentifier, srcNodeId, signal);
+		if (!node) throw new Error(`Node ${srcNodeId} not found in drive ${driveIdentifier}`);
+		if (node.kind === "folder") await this.reactor.execute(driveIdentifier, "main", [updateFolderAction({
+			folderId: srcNodeId,
+			parentFolderId: targetParentFolderId ?? null
+		})], signal);
+		else {
+			const metadata = {
+				kind: "file",
+				parentFolderId: targetParentFolderId ?? null,
+				documentType: node.documentType
+			};
+			await this.reactor.execute(driveIdentifier, "main", [removeRelationshipAction(driveIdentifier, srcNodeId, DRIVE_CHILD_RELATIONSHIP_TYPE), addRelationshipAction(driveIdentifier, srcNodeId, DRIVE_CHILD_RELATIONSHIP_TYPE, metadata)], signal);
+		}
+		const drive = await this.reactor.get(driveIdentifier, void 0, signal);
+		return this.toLegacyDriveDocument(drive, driveIdentifier);
+	}
+	async copyNode(driveIdentifier, srcNodeId, targetParentFolderId, signal) {
+		if (!await this.readModel.getNode(driveIdentifier, srcNodeId, signal)) throw new Error(`Node ${srcNodeId} not found in drive ${driveIdentifier}`);
+		const subtree = await this.readModel.getDescendants(driveIdentifier, srcNodeId, signal);
+		if (targetParentFolderId !== void 0 && subtree.some((n) => n.id === targetParentFolderId)) throw new Error(`Cannot copy node ${srcNodeId} into itself or one of its descendants (target: ${targetParentFolderId})`);
+		const idMap = /* @__PURE__ */ new Map();
+		for (const node of subtree) idMap.set(node.id, generateId());
+		const jobs = [];
+		const driveActions = [];
+		const fileCreateKeys = [];
+		for (const node of subtree) {
+			const newId = idMap.get(node.id);
+			let newParent;
+			if (node.id === srcNodeId) newParent = targetParentFolderId ?? null;
+			else {
+				if (node.parentFolder == null) throw new Error(`copyNode: descendant ${node.id} has no parentFolder`);
+				const mapped = idMap.get(node.parentFolder);
+				if (mapped === void 0) throw new Error(`copyNode: descendant ${node.id} parent ${node.parentFolder} missing from idMap`);
+				newParent = mapped;
+			}
+			if (node.kind === "folder") {
+				driveActions.push(addFolderAction({
+					folderId: newId,
+					parentFolderId: newParent,
+					name: node.name
+				}));
+				continue;
+			}
+			const srcDoc = await this.reactor.get(node.id, void 0, signal);
+			const documentModelModule = await this.reactor.getDocumentModelModule(srcDoc.header.documentType);
+			const duplicated = replayDocument(srcDoc.initialState, srcDoc.operations, documentModelModule.reducer, createPresignedHeader(newId, srcDoc.header.documentType));
+			duplicated.header.name = node.name;
+			const createInput = {
+				model: duplicated.header.documentType,
+				version: 0,
+				documentId: newId,
+				signing: {
+					signature: newId,
+					publicKey: duplicated.header.sig.publicKey,
+					nonce: duplicated.header.sig.nonce,
+					createdAtUtcIso: duplicated.header.createdAtUtcIso,
+					documentType: duplicated.header.documentType
+				},
+				slug: duplicated.header.slug,
+				name: duplicated.header.name,
+				branch: duplicated.header.branch,
+				meta: duplicated.header.meta,
+				protocolVersions: duplicated.header.protocolVersions ?? { "base-reducer": 2 }
+			};
+			const createKey = `create:${newId}`;
+			jobs.push({
+				key: createKey,
+				documentId: newId,
+				scope: "document",
+				branch: "main",
+				actions: [createDocumentAction(createInput), upgradeDocumentAction({
+					documentId: newId,
+					model: duplicated.header.documentType,
+					fromVersion: 0,
+					toVersion: duplicated.state.document.version,
+					initialState: duplicated.state
+				})],
+				dependsOn: []
+			});
+			fileCreateKeys.push(createKey);
+			const metadata = {
+				kind: "file",
+				parentFolderId: newParent,
+				documentType: duplicated.header.documentType
+			};
+			driveActions.push(addRelationshipAction(driveIdentifier, newId, DRIVE_CHILD_RELATIONSHIP_TYPE, metadata));
+		}
+		if (driveActions.length > 0) jobs.push({
+			key: "drive",
+			documentId: driveIdentifier,
+			scope: "document",
+			branch: "main",
+			actions: driveActions,
+			dependsOn: fileCreateKeys
+		});
+		if (jobs.length > 0) {
+			const request = { jobs };
+			await this.reactor.executeBatch(request, signal);
+		}
+		const drive = await this.reactor.get(driveIdentifier, void 0, signal);
+		return this.toLegacyDriveDocument(drive, driveIdentifier);
+	}
+	async getNode(driveIdentifier, nodeId, signal) {
+		const node = await this.readModel.getNode(driveIdentifier, nodeId, signal);
+		if (!node) throw new Error(`Node ${nodeId} not found in drive ${driveIdentifier}`);
+		return this.toLegacyNode(node);
+	}
+	async listNodes(driveIdentifier, parentFolder, paging, signal) {
+		const page = await this.readModel.listChildren(driveIdentifier, parentFolder, paging, signal);
+		return {
+			results: page.results.map((node) => this.toLegacyNode(node)),
+			options: page.options,
+			...page.nextCursor !== void 0 ? { nextCursor: page.nextCursor } : {},
+			...page.totalCount !== void 0 ? { totalCount: page.totalCount } : {}
+		};
+	}
+	toLegacyNode(node) {
+		if (node.kind === "file") {
+			const file = node;
+			return {
+				id: file.id,
+				kind: "file",
+				name: file.name,
+				parentFolder: file.parentFolder,
+				documentType: file.documentType
+			};
+		}
+		const folder = node;
+		return {
+			id: folder.id,
+			kind: "folder",
+			name: folder.name,
+			parentFolder: folder.parentFolder
+		};
+	}
+	async toLegacyDriveDocument(doc, driveId) {
+		if (doc.header.documentType !== "powerhouse/reactor-drive") throw new Error(`Document ${doc.header.id} is not a reactor-drive document`);
+		const allNodes = await this.readModel.listAll(driveId);
+		const legacy = structuredClone(doc);
+		const existingGlobal = legacy.state.global;
+		legacy.state.global = {
+			name: existingGlobal.name ?? "",
+			icon: existingGlobal.icon ?? null,
+			nodes: allNodes.map((n) => this.toLegacyNode(n))
+		};
+		return legacy;
+	}
+	orderDeepestFirst(folders, rootId) {
+		const depthById = /* @__PURE__ */ new Map();
+		const compute = (id) => {
+			if (id === rootId) return 0;
+			const cached = depthById.get(id);
+			if (cached !== void 0) return cached;
+			const folder = folders.find((f) => f.id === id);
+			if (!folder) return 0;
+			const depth = compute(folder.parentFolder ?? rootId) + 1;
+			depthById.set(id, depth);
+			return depth;
+		};
+		return folders.slice().sort((a, b) => compute(b.id) - compute(a.id));
+	}
+};
+//#endregion
+//#region src/subgraph/schema.ts
+const typeDefs = gql`
+  enum ReactorDriveNodeKind {
+    FILE
+    FOLDER
+  }
+
+  input ReactorDrivePagingInput {
+    cursor: String
+    limit: Int
+  }
+
+  type ReactorDriveFileNode {
+    id: ID!
+    driveId: ID!
+    name: String!
+    parentFolder: ID
+    documentType: String!
+  }
+
+  type ReactorDriveFolderNode {
+    id: ID!
+    driveId: ID!
+    name: String!
+    parentFolder: ID
+    children(
+      paging: ReactorDrivePagingInput
+      kind: ReactorDriveNodeKind
+    ): ReactorDriveNodePage!
+  }
+
+  union ReactorDriveNode = ReactorDriveFileNode | ReactorDriveFolderNode
+
+  type ReactorDriveNodePage {
+    results: [ReactorDriveNode!]!
+    nextCursor: String
+    hasMore: Boolean!
+    totalCount: Int
+  }
+
+  type ReactorDrive {
+    id: ID!
+    name: String!
+    icon: String
+    sharingType: String!
+    availableOffline: Boolean!
+    rootNodes(
+      paging: ReactorDrivePagingInput
+      kind: ReactorDriveNodeKind
+    ): ReactorDriveNodePage!
+  }
+
+  type Query {
+    reactorDrive(id: ID!): ReactorDrive
+    reactorDriveNode(driveId: ID!, id: ID!): ReactorDriveNode
+    reactorDriveDescendants(driveId: ID!, root: ID!): [ReactorDriveNode!]!
+  }
+`;
+//#endregion
+//#region src/subgraph/resolvers.ts
+const DEFAULT_LIMIT = 100;
+function toPaging(input) {
+	if (!input) return void 0;
+	return {
+		cursor: input.cursor ?? "",
+		limit: input.limit ?? DEFAULT_LIMIT
+	};
+}
+function filterByKind(page, kind) {
+	if (!kind) return page;
+	const wanted = kind === "FILE" ? "file" : "folder";
+	return {
+		...page,
+		results: page.results.filter((node) => node.kind === wanted)
+	};
+}
+function shapePage(page) {
+	return {
+		results: page.results,
+		nextCursor: page.nextCursor,
+		hasMore: page.nextCursor !== void 0,
+		totalCount: page.totalCount
+	};
+}
+/**
+* Builds GraphQL resolvers backed by the drive read model. The resolvers are
+* pure — every external dependency is read off the GraphQL context. Wiring
+* the resolvers into a subgraph (e.g. `reactor-api`'s `ISubgraph`) is the
+* caller's responsibility.
+*/
+function createReactorDriveResolvers() {
+	return {
+		Query: {
+			async reactorDrive(_root, args, ctx) {
+				const document = await ctx.reactorClient.get(args.id);
+				if (document.header.documentType !== "powerhouse/reactor-drive") return null;
+				return {
+					id: document.header.id,
+					name: document.state.global.name,
+					icon: document.state.global.icon,
+					sharingType: document.state.local.sharingType,
+					availableOffline: document.state.local.availableOffline
+				};
+			},
+			async reactorDriveNode(_root, args, ctx) {
+				return ctx.readModel.getNode(args.driveId, args.id);
+			},
+			async reactorDriveDescendants(_root, args, ctx) {
+				return ctx.readModel.getDescendants(args.driveId, args.root);
+			}
+		},
+		ReactorDrive: { async rootNodes(parent, args, ctx) {
+			return shapePage(filterByKind(await ctx.readModel.listChildren(parent.id, null, toPaging(args.paging)), args.kind));
+		} },
+		ReactorDriveFolderNode: { async children(parent, args, ctx) {
+			return shapePage(filterByKind(await ctx.readModel.listChildren(parent.driveId, parent.id, toPaging(args.paging)), args.kind));
+		} },
+		ReactorDriveNode: { __resolveType(node) {
+			return node.kind === "file" ? "ReactorDriveFileNode" : "ReactorDriveFolderNode";
+		} }
+	};
+}
+//#endregion
+//#region src/migration/migrate-legacy-state.ts
+/**
+* Translates a legacy `document-drive` `state.global.nodes` array into the
+* action vocabulary used by the new reactor-drive module.
+*
+* Folder nodes are emitted as `ADD_FOLDER` actions targeting the drive
+* document. File nodes are emitted as `ADD_RELATIONSHIP` actions on the drive
+* with `drive/child` metadata carrying the parent folder id. File nodes
+* assume the underlying PHDocument still exists under the same id — the
+* migration only re-links it into the new drive, it does not recreate
+* documents.
+*
+* Re-running the migration is safe: existing `DriveNode` rows are skipped
+* so already-migrated nodes are left untouched.
+*/
+async function migrateLegacyDriveState(args) {
+	const { reactor, readModel, driveId, nodes, signal } = args;
+	const branch = args.branch ?? "main";
+	const ordered = orderLegacyNodes(nodes);
+	const actions = [];
+	let skippedExisting = 0;
+	for (const node of ordered) {
+		if (await readModel.getNode(driveId, node.id, signal)) {
+			skippedExisting += 1;
+			continue;
+		}
+		actions.push(toAction(driveId, node));
+	}
+	if (actions.length === 0) return {
+		emittedActions: 0,
+		skippedExisting
+	};
+	await reactor.execute(driveId, branch, actions, signal);
+	return {
+		emittedActions: actions.length,
+		skippedExisting
+	};
+}
+function toAction(driveId, node) {
+	if (node.kind === "folder") return addFolderAction({
+		folderId: node.id,
+		parentFolderId: node.parentFolder ?? null,
+		name: node.name
+	});
+	const fileNode = node;
+	const metadata = {
+		kind: "file",
+		parentFolderId: fileNode.parentFolder ?? null,
+		documentType: fileNode.documentType
+	};
+	return addRelationshipAction(driveId, fileNode.id, DRIVE_CHILD_RELATIONSHIP_TYPE, metadata);
+}
+/**
+* Sorts legacy nodes so that any folder appears before its children. The
+* legacy state stores nodes in insertion order, which usually already
+* satisfies that property, but defensive sorting keeps replay deterministic
+* if the input was constructed out of order.
+*/
+function orderLegacyNodes(nodes) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const node of nodes) byId.set(node.id, node);
+	const visited = /* @__PURE__ */ new Set();
+	const ordered = [];
+	for (const start of nodes) {
+		if (visited.has(start.id)) continue;
+		const chain = [];
+		const seenInWalk = /* @__PURE__ */ new Set();
+		let current = start;
+		while (current && !visited.has(current.id) && !seenInWalk.has(current.id)) {
+			seenInWalk.add(current.id);
+			chain.push(current);
+			const parentId = current.parentFolder;
+			current = parentId ? byId.get(parentId) : void 0;
+		}
+		while (chain.length > 0) {
+			const node = chain.pop();
+			if (visited.has(node.id)) continue;
+			visited.add(node.id);
+			ordered.push(node);
+		}
+	}
+	return ordered;
+}
+//#endregion
+export { DRIVE_CHILD_RELATIONSHIP_TYPE, DriveNodeView, NodeProcessor, REACTOR_DRIVE_DOCUMENT_TYPE, REACTOR_DRIVE_FILE_EXTENSION, ReactorDriveClient, addFolderAction, createReactorDriveResolvers, getReactorDriveMigrationStatus, migrateLegacyDriveState, reactorDriveActions, reactorDriveCreateDocument, reactorDriveCreateState, reactorDriveDocumentModelModule, reactorDriveDocumentReducer, reactorDriveStateReducer, typeDefs as reactorDriveSubgraphTypeDefs, removeFolderAction, resolveCollision, runReactorDriveMigrations, setAvailableOfflineAction, setDriveIconAction, setDriveNameAction, setSharingTypeAction, updateFolderAction };
+
+//# sourceMappingURL=index.js.map