@powerhousedao/codegen 6.0.0-dev.12 → 6.0.0-dev.120

package/dist/file-builders-BRJcuumC.mjs

@@ -0,0 +1,1675 @@
+import { $ as documentModelGenActionsFileTemplate, A as makeActionImportNames, B as documentModelSchemaIndexTemplate, C as driveEditorDriveContentsFileTemplate, D as upgradeManifestTemplate, E as upgradeTransitionTemplate, F as documentModelModuleFileTemplate, G as documentModelOperationsModuleCreatorsFileTemplate, H as documentModelPhFactoriesFileTemplate, I as documentModelIndexTemplate, J as documentModelGenIndexFileTemplate, K as documentModelOperationModuleActionsFileTemplate, L as documentModelHooksFileTemplate, M as makeTestCaseForAction, N as documentModelTestFileTemplate, O as documentModelSrcUtilsTemplate, P as documentModelSrcIndexFileTemplate, Q as documentModelGenControllerFileTemplate, R as documentModelGenUtilsTemplate, S as driveExplorerFileTemplate, T as documentModelUtilsTemplate, U as documentModelOperationsModuleOperationsFileTemplate, V as documentModelGenReducerFileTemplate, W as documentModelOperationsModuleErrorFileTemplate, X as documentModelDocumentSchemaFileTemplate, Y as documentModelDocumentTypeTemplate, Z as documentModelGenCreatorsFileTemplate, _ as driveExplorerNavigationBreadcrumbsFileTemplate, a as subgraphLibFileTemplate, b as driveEditorFilesFileTemplate, c as relationalDbMigrationsTemplate, d as processorsIndexTemplate, et as documentModelRootActionsFileTemplate, f as processorsFactoryTemplate, g as driveEditorConfigFileTemplate, h as driveEditorEditorFileTemplate, i as customSubgraphSchemaTemplate, l as relationalDbIndexTemplate, m as analyticsFactoryTemplate, mt as packageJsonTemplate, n as documentModelSubgraphSchemaTemplate, nt as documentEditorEditorFileTemplate, o as subgraphIndexFileTemplate, p as analyticsIndexTemplate, r as customSubgraphResolversTemplate, rt as docsFromCliHelpTemplate, s as relationalDbSchemaTemplate, t as documentModelSubgraphResolversTemplate, tt as documentEditorModuleFileTemplate, u as relationalDbFactoryTemplate, v as folderTreeFileTemplate, w as createDocumentFileTemplate, x as emptyStateFileTemplate, y as driveEditorFoldersFileTemplate, z as documentModelGenTypesTemplate } from "./templates-BYDhXDXu.mjs";
+import { getDocumentModelDirName, getDocumentModelOperationsModuleVariableNames, getDocumentModelVariableNames, getEditorVariableNames } from "./src/name-builders/index.mjs";
+import { applyGraphQLTypePrefixes, buildObjectLiteral, buildTsMorphProject, ensureDirectoriesExist, extractTypeNames, formatSourceFileWithPrettier, getDocumentTypeMetadata, getInitialStates, getObjectLiteral, getOrCreateDirectory, getOrCreateSourceFile, getPreviousVersionSourceFile, getVariableDeclarationByTypeName } from "./src/utils/index.mjs";
+import { VERSIONED_DEPENDENCIES, VERSIONED_DEV_DEPENDENCIES, directoryExists, fileExists, makeVersionedDependencies } from "@powerhousedao/shared/clis";
+import { camelCase, kebabCase, pascalCase } from "change-case";
+import fs, { copyFile, mkdir, readdir, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { stripVTControlCharacters } from "node:util";
+import path$1 from "path";
+import { ts } from "@tmpl/core";
+import { IndentationText, Project, SyntaxKind, VariableDeclarationKind, ts as ts$1 } from "ts-morph";
+import { format } from "prettier";
+import { generate } from "@graphql-codegen/cli";
+import { generatorTypeDefs, validationSchema } from "@powerhousedao/document-engineering/graphql";
+import { existsSync } from "fs";
+//#region src/file-builders/processors/analytics.ts
+async function tsMorphGenerateAnalyticsProcessor(args) {
+	const { project, documentTypes, pascalCaseName, dirPath, camelCaseName } = args;
+	await makeIndexFile$1({
+		project,
+		pascalCaseName,
+		dirPath
+	});
+	await makeFactoryFile$1({
+		project,
+		pascalCaseName,
+		camelCaseName,
+		dirPath,
+		documentTypes
+	});
+}
+async function makeIndexFile$1(v) {
+	const template = analyticsIndexTemplate(v);
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(v.project, path$1.join(v.dirPath, "index.ts"));
+	if (alreadyExists) return;
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeFactoryFile$1(v) {
+	const template = analyticsFactoryTemplate(v);
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(v.project, path$1.join(v.dirPath, "factory.ts"));
+	if (alreadyExists) return;
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+//#endregion
+//#region src/file-builders/processors/relational-db.ts
+async function tsMorphGenerateRelationalDbProcessor(args) {
+	const { project, documentTypes, camelCaseName, pascalCaseName, dirPath } = args;
+	await makeIndexFile({
+		project,
+		pascalCaseName,
+		dirPath
+	});
+	await makeFactoryFile({
+		project,
+		pascalCaseName,
+		camelCaseName,
+		dirPath,
+		documentTypes
+	});
+	await makeMigrationsFile({
+		project,
+		dirPath
+	});
+	await makeSchemaFile({
+		project,
+		dirPath
+	});
+}
+async function makeIndexFile(v) {
+	const template = relationalDbIndexTemplate(v);
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(v.project, path$1.join(v.dirPath, "index.ts"));
+	if (alreadyExists) return;
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeFactoryFile(v) {
+	const template = relationalDbFactoryTemplate(v);
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(v.project, path$1.join(v.dirPath, "factory.ts"));
+	if (alreadyExists) return;
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeSchemaFile(v) {
+	const template = relationalDbSchemaTemplate();
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(v.project, path$1.join(v.dirPath, "schema.ts"));
+	if (alreadyExists) return;
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeMigrationsFile(v) {
+	const template = relationalDbMigrationsTemplate();
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(v.project, path$1.join(v.dirPath, "migrations.ts"));
+	if (alreadyExists) return;
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+//#endregion
+//#region src/file-builders/processors/processor.ts
+async function tsMorphGenerateProcessor(args) {
+	const { processorName, documentTypes, rootDir, processorType, processorApps } = args;
+	const kebabCaseName = kebabCase(processorName);
+	const camelCaseName = camelCase(processorName);
+	const pascalCaseName = pascalCase(processorName);
+	const processorsDirPath = path$1.join(rootDir, "processors");
+	const dirPath = path$1.join(processorsDirPath, kebabCaseName);
+	const sourceFilesPath = path$1.join(processorsDirPath, "**/*");
+	const project = buildTsMorphProject(rootDir);
+	await ensureDirectoriesExist(project, processorsDirPath, dirPath);
+	project.addSourceFilesAtPaths(sourceFilesPath);
+	if (processorType === "analytics") await tsMorphGenerateAnalyticsProcessor({
+		processorName,
+		documentTypes,
+		rootDir,
+		camelCaseName,
+		dirPath,
+		kebabCaseName,
+		pascalCaseName,
+		processorsDirPath,
+		project
+	});
+	else await tsMorphGenerateRelationalDbProcessor({
+		processorName,
+		documentTypes,
+		rootDir,
+		camelCaseName,
+		dirPath,
+		kebabCaseName,
+		pascalCaseName,
+		processorsDirPath,
+		project
+	});
+	await updateIndexFile({
+		processorsDirPath,
+		project
+	});
+	for (const processorApp of processorApps) {
+		await updateFactoryFile({
+			processorsDirPath,
+			project,
+			camelCaseName,
+			dirPath,
+			processorApp
+		});
+		await updateAppProcessorsFile({
+			processorsDirPath,
+			processorApp,
+			project,
+			dirPath,
+			pascalCaseName,
+			camelCaseName
+		});
+	}
+	await project.save();
+}
+async function updateAppProcessorsFile(args) {
+	const { project, processorsDirPath, processorApp, dirPath, pascalCaseName, camelCaseName } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(processorsDirPath, `${processorApp}.ts`));
+	const processorClassName = `${pascalCaseName}Processor`;
+	const processorClassModuleSpecifier = `./${path$1.join(path$1.basename(dirPath), "index.js")}`;
+	const processorFactoryName = `${camelCaseName}ProcessorFactory`;
+	const processorFactoryModuleSpecifier = `./${path$1.join(path$1.basename(dirPath), "factory.js")}`;
+	const exportedNames = sourceFile.getExportDeclarations().flatMap((e) => e.getNamedExports().map((n) => n.getText()));
+	if (!exportedNames.includes(processorClassName)) sourceFile.addExportDeclaration({
+		namedExports: [processorClassName],
+		moduleSpecifier: processorClassModuleSpecifier
+	});
+	if (!exportedNames.includes(processorFactoryName)) sourceFile.addExportDeclaration({
+		namedExports: [processorFactoryName],
+		moduleSpecifier: processorFactoryModuleSpecifier
+	});
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function updateIndexFile(v) {
+	const { project, processorsDirPath } = v;
+	const template = processorsIndexTemplate;
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, path$1.join(processorsDirPath, "index.ts"));
+	if (!alreadyExists) sourceFile.replaceWithText(template);
+	if (!sourceFile.getExportDeclarations().flatMap((e) => e.getNamedExports().map((n) => n.getText())).includes("processorFactory")) sourceFile.addExportDeclaration({
+		namedExports: ["processorFactory"],
+		moduleSpecifier: "./factory.ts"
+	});
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function updateFactoryFile(v) {
+	const { project, processorsDirPath, processorApp, dirPath, camelCaseName } = v;
+	const template = processorsFactoryTemplate;
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, path$1.join(processorsDirPath, "factory.ts"));
+	if (!alreadyExists) sourceFile.replaceWithText(template);
+	const processorFactoryName = `${camelCaseName}ProcessorFactory`;
+	const processorFactoryModuleSpecifier = `./${path$1.join(path$1.basename(dirPath), "factory.js")}`;
+	const addFactoriesFunctionName = camelCase(`add_${processorApp}_ProcessorFactories`);
+	const factoriesArrayName = camelCase(`${processorApp}ProcessorFactories`);
+	const functionBody = sourceFile.getFunctionOrThrow(addFactoriesFunctionName).getBodyOrThrow().asKindOrThrow(ts$1.SyntaxKind.Block);
+	const factoriesArray = functionBody.getDescendantsOfKind(ts$1.SyntaxKind.VariableStatement).flatMap((d) => d.getDescendantsOfKind(ts$1.SyntaxKind.VariableDeclaration)).find((d) => d.getName() === factoriesArrayName)?.getDescendantsOfKind(ts$1.SyntaxKind.ArrayLiteralExpression).at(0);
+	if (!factoriesArray) throw new Error(`"${factoriesArrayName}" array is missing in "${addFactoriesFunctionName}"`);
+	const factoryFunctionInvocation = `${processorFactoryName}(module)`;
+	if (!factoriesArray.getElements().map((e) => e.getText()).includes(factoryFunctionInvocation)) {
+		functionBody.insertStatements(0, `const { ${processorFactoryName} } = await import("${processorFactoryModuleSpecifier}");`);
+		factoriesArray.addElement(factoryFunctionInvocation);
+	}
+	await formatSourceFileWithPrettier(sourceFile);
+}
+//#endregion
+//#region src/codegen/graphql.ts
+const getDirectories = async (source) => {
+	return (await fs.readdir(source, { withFileTypes: true })).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent);
+};
+const scalars = {
+	Unknown: "unknown",
+	DateTime: "string",
+	Attachment: "string",
+	Address: "`${string}:0x${string}`",
+	...generatorTypeDefs
+};
+const scalarsValidation = {
+	Unknown: "z.unknown()",
+	DateTime: "z.string().datetime()",
+	Attachment: "z.string()",
+	Address: "z.custom<`${string}:0x${string}`>((val) => /^[a-zA-Z0-9]+:0x[a-fA-F0-9]{40}$/.test(val as string))",
+	...validationSchema
+};
+const avoidOptionals = {
+	field: true,
+	inputValue: false
+};
+const maybeValue = "T | null | undefined";
+const typescriptConfig = {
+	avoidOptionals,
+	scalars,
+	strictScalars: true,
+	enumsAsTypes: true,
+	skipTypename: true,
+	maybeValue
+};
+const validationSchemaConfig = {
+	avoidOptionals,
+	scalars,
+	strictScalars: true,
+	enumsAsTypes: true,
+	skipTypename: true,
+	importFrom: `./types.js`,
+	schema: "zodv4",
+	useTypeImports: true,
+	scalarSchemas: scalarsValidation,
+	directives: { equals: { value: ["regex", "/^$1$/"] } },
+	withObjectType: true,
+	maybeValue
+};
+function buildSchemasForModules(modules) {
+	const schemaStrings = [];
+	for (const module of modules) {
+		schemaStrings.push(`# ${module.name}`);
+		const operationsSchemas = module.operations.map((operation) => operation.schema).filter((schema) => schema !== null);
+		schemaStrings.push(...operationsSchemas);
+	}
+	return schemaStrings;
+}
+function buildGraphqlDocumentStringForSpecification(specification) {
+	const customScalarSchemas = Object.keys(scalars).map((k) => `scalar ${k}`).join("\n");
+	const stateSchemas = Object.values(specification.state).map((state) => state.schema);
+	const moduleSchemas = buildSchemasForModules(specification.modules);
+	return [
+		customScalarSchemas,
+		...stateSchemas,
+		...moduleSchemas
+	];
+}
+async function formatContentWithPrettier(path, content) {
+	return await format(content, { parser: "typescript" });
+}
+async function generateTypesAndZodSchemasFromGraphql(args) {
+	const { dirName, schema, skipFormat, writeFile, watch } = args;
+	await generate({
+		overwrite: true,
+		watch,
+		hooks: { beforeOneFileWrite: skipFormat ? void 0 : formatContentWithPrettier },
+		generates: {
+			[`${dirName}/gen/schema/types.ts`]: {
+				schema,
+				config: typescriptConfig,
+				plugins: [{ typescript: typescriptConfig }]
+			},
+			[`${dirName}/gen/schema/zod.ts`]: {
+				schema,
+				config: validationSchemaConfig,
+				plugins: [{ add: { content: "/* eslint-disable @typescript-eslint/no-empty-object-type */" } }, { "graphql-codegen-typescript-validation-schema": validationSchemaConfig }]
+			}
+		}
+	}, writeFile);
+}
+async function generateDocumentModelZodSchemas(args) {
+	const { documentModelDirPath, specification, writeFile = true, skipFormat = false, watch = false } = args;
+	const schema = buildGraphqlDocumentStringForSpecification(specification).filter(Boolean).join("\n\n");
+	await generateTypesAndZodSchemasFromGraphql({
+		dirName: documentModelDirPath,
+		schema,
+		writeFile,
+		skipFormat,
+		watch
+	});
+	await fs.writeFile(path.join(documentModelDirPath, "schema.graphql"), schema);
+}
+const generateSchemas = async (inDir, { watch = false, skipFormat = false, writeFile = true, outDir = inDir } = {}) => {
+	const dirs = await getDirectories(inDir);
+	const inputs = await Promise.all(dirs.map(async (dir) => {
+		const documentModelJsonFile = await fs.readFile(path.join(dir.parentPath, dir.name, `${dir.name}.json`), "utf-8");
+		const parsedJson = JSON.parse(documentModelJsonFile);
+		const latestSpecification = parsedJson.specifications[parsedJson.specifications.length - 1];
+		const schema = buildGraphqlDocumentStringForSpecification(latestSpecification).filter(Boolean).join("\n\n");
+		return {
+			dirName: path.join(outDir, dir.name),
+			schema
+		};
+	}));
+	await Promise.all(inputs.map(async ({ schema, dirName }) => {
+		await generateTypesAndZodSchemasFromGraphql({
+			schema,
+			dirName,
+			writeFile,
+			skipFormat,
+			watch
+		});
+	}));
+};
+//#endregion
+//#region src/file-builders/boilerplate/package.json.ts
+async function buildBoilerplatePackageJson(args) {
+	const { name, tag, version, workspace } = args;
+	return packageJsonTemplate(name, await makeVersionedDependencies({
+		names: VERSIONED_DEPENDENCIES,
+		tag,
+		version
+	}), await makeVersionedDependencies({
+		names: VERSIONED_DEV_DEPENDENCIES,
+		tag,
+		version
+	}));
+}
+//#endregion
+//#region src/file-builders/clis/generate-cli-docs.ts
+function getCommandHelpInfo(entry) {
+	return {
+		name: entry.name,
+		description: entry.command.description ?? "",
+		helpTopics: entry.command.helpTopics?.() ?? []
+	};
+}
+function getCommandsHelpInfo(entries) {
+	return entries.map(getCommandHelpInfo);
+}
+function makeCliDocsFromHelp(args) {
+	const { cliDescription, docsIntroduction, docsTitle, entries } = args;
+	return stripVTControlCharacters(docsFromCliHelpTemplate({
+		cliDescription,
+		docsIntroduction,
+		docsTitle,
+		commandsHelpInfo: getCommandsHelpInfo(entries)
+	}));
+}
+async function writeCliDocsMarkdownFile(args) {
+	const { filePath, ...restArgs } = args;
+	await writeFile(filePath, makeCliDocsFromHelp(restArgs), { encoding: "utf-8" });
+}
+//#endregion
+//#region src/file-builders/editor-common.ts
+/** Generates the `module.ts` file for a document editor or drive editor */
+function makeEditorModuleFile({ project, editorDirPath, editorName, documentModelId, editorId, legacyMultipleDocumentTypes }) {
+	if (documentModelId && !!legacyMultipleDocumentTypes) throw new Error("Cannot specify both documentModelId and legacyMultipleDocumentTypes");
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(editorDirPath, "module.ts"));
+	sourceFile.replaceWithText("");
+	const template = documentEditorModuleFileTemplate({
+		editorName,
+		editorId,
+		pascalCaseEditorName: pascalCase(editorName),
+		documentTypes: documentModelId ? `["${documentModelId}"]` : JSON.stringify(legacyMultipleDocumentTypes)
+	});
+	sourceFile.replaceWithText(template);
+}
+//#endregion
+//#region src/file-builders/index-files.ts
+/**
+* Makes a legacy index.ts file for the modules file which exports the modules as individual exports instead of an array of named exports.
+*/
+function makeLegacyIndexFile({ project, modulesDirPath, modules }) {
+	const indexSourceFilePath = path.join(modulesDirPath, "index.ts");
+	let indexSourceFile = project.getSourceFile(indexSourceFilePath);
+	if (!indexSourceFile) indexSourceFile = project.createSourceFile(indexSourceFilePath, "");
+	else indexSourceFile.replaceWithText("");
+	indexSourceFile.addExportDeclarations(modules.map(({ versionedName, unversionedName, moduleSpecifier }) => ({
+		namedExports: [versionedName ? `${unversionedName} as ${versionedName}` : unversionedName],
+		moduleSpecifier
+	})));
+}
+//#endregion
+//#region src/file-builders/module-files.ts
+/**
+* Makes a file which exports the modules from the module.ts files in the given directory as a variable declaration.
+*/
+async function makeModulesFile({ project, modulesDirPath, outputFileName, typeName, variableName, variableType, shouldMakeLegacyIndexFile = true, moduleFileName = "module.ts" }) {
+	await ensureDirectoriesExist(project, modulesDirPath);
+	const modulesSourceFilesPath = path.join(modulesDirPath, "**/*");
+	project.addSourceFilesAtPaths(modulesSourceFilesPath);
+	const { directory: modulesDir } = getOrCreateDirectory(project, modulesDirPath);
+	const modules = modulesDir.getDescendantSourceFiles().filter((file) => file.getBaseName().includes(moduleFileName)).map((file) => getVariableDeclarationByTypeName(file, typeName)).filter((v) => v !== void 0).map((module) => {
+		const sourceFile = module.getSourceFile();
+		const moduleSpecifier = modulesDir.getRelativePathAsModuleSpecifierTo(sourceFile.getFilePath()) + ".js";
+		const versionDir = getVersionDirFromModuleSpecifier(moduleSpecifier);
+		const unversionedName = module.getName();
+		return {
+			versionedName: versionDir ? `${unversionedName}${pascalCase(versionDir)}` : void 0,
+			unversionedName,
+			moduleSpecifier
+		};
+	});
+	const { sourceFile: moduleExportsSourceFile } = getOrCreateSourceFile(project, path.join(modulesDirPath, outputFileName));
+	moduleExportsSourceFile.replaceWithText("");
+	const importDeclarations = [{
+		namedImports: [typeName],
+		moduleSpecifier: "document-model",
+		isTypeOnly: true
+	}, ...modules.map(({ versionedName, unversionedName, moduleSpecifier }) => ({
+		namedImports: [versionedName ? `${unversionedName} as ${versionedName}` : unversionedName],
+		moduleSpecifier
+	}))];
+	for (const declaration of importDeclarations) if (!moduleExportsSourceFile.getImportDeclaration((importDeclaration) => importDeclaration.getNamedImports().some((importSpecifier) => declaration.namedImports.includes(importSpecifier.getName())))) moduleExportsSourceFile.addImportDeclaration(declaration);
+	const moduleExportsVariableStatementInput = {
+		isExported: true,
+		declarationKind: VariableDeclarationKind.Const,
+		declarations: [{
+			name: variableName,
+			type: variableType,
+			initializer: `[]`
+		}]
+	};
+	let moduleExportsVariableStatement = moduleExportsSourceFile.getVariableStatement(variableName);
+	if (!moduleExportsVariableStatement) moduleExportsVariableStatement = moduleExportsSourceFile.addVariableStatement(moduleExportsVariableStatementInput);
+	else moduleExportsVariableStatement.set(moduleExportsVariableStatementInput);
+	(moduleExportsVariableStatement.getDeclarations().at(0)?.getInitializerIfKind(SyntaxKind.ArrayLiteralExpression))?.addElements(modules.map((module) => module.versionedName ?? module.unversionedName), { useNewLines: true });
+	if (shouldMakeLegacyIndexFile) makeLegacyIndexFile({
+		project,
+		modulesDirPath,
+		modules
+	});
+	await project.save();
+}
+async function makeUpgradeManifestsFile(args) {
+	const { project, projectDir } = args;
+	await makeModulesFile({
+		project,
+		modulesDirPath: path.join(projectDir, "document-models"),
+		outputFileName: "upgrade-manifests.ts",
+		typeName: "UpgradeManifest",
+		variableName: "upgradeManifests",
+		variableType: "UpgradeManifest<readonly number[]>[]",
+		moduleFileName: "upgrade-manifest.ts",
+		shouldMakeLegacyIndexFile: false
+	});
+}
+/** Generates the `document-models.ts` file which exports the document models defined in each document model dir's `module.ts` file */
+async function makeDocumentModelModulesFile({ project, projectDir }) {
+	await makeModulesFile({
+		project,
+		modulesDirPath: path.join(projectDir, "document-models"),
+		outputFileName: "document-models.ts",
+		typeName: "DocumentModelModule",
+		variableName: "documentModels",
+		variableType: "DocumentModelModule<any>[]"
+	});
+}
+/** Generates the `editors.ts` file which exports the editors defined in each editor dir's `module.ts` file */
+async function makeEditorsModulesFile(project, projectDir) {
+	await makeModulesFile({
+		project,
+		modulesDirPath: path.join(projectDir, "editors"),
+		outputFileName: "editors.ts",
+		typeName: "EditorModule",
+		variableName: "editors",
+		variableType: "EditorModule[]"
+	});
+}
+function getVersionDirFromModuleSpecifier(moduleSpecifier) {
+	return moduleSpecifier.match(/\/(v\d+)(?=\/)/)?.[1];
+}
+/**
+* Adds the upgradeManifests export to an existing document-models.ts file.
+* Searches for upgrade-manifest.ts files in each document model's upgrades directory,
+* adds imports for each, and creates the upgradeManifests array export.
+*/
+function makeUpgradeManifestsExport({ project, modulesDirPath, outputFilePath, variableName, variableType, typeName }) {
+	const absoluteModulesDirPath = path.resolve(modulesDirPath);
+	const absoluteOutputFilePath = path.resolve(outputFilePath);
+	const upgradeManifestGlob = `${absoluteModulesDirPath}/**/upgrade-manifest.ts`;
+	project.addSourceFilesAtPaths(upgradeManifestGlob);
+	const upgradeManifestFiles = project.getSourceFiles().filter((file) => file.getFilePath().includes("upgrade-manifest.ts")).filter((file) => file.getFilePath().startsWith(absoluteModulesDirPath));
+	if (upgradeManifestFiles.length === 0) return;
+	let outputSourceFile = project.getSourceFile(absoluteOutputFilePath);
+	if (outputSourceFile) outputSourceFile.refreshFromFileSystemSync();
+	else {
+		project.addSourceFilesAtPaths(absoluteOutputFilePath);
+		outputSourceFile = project.getSourceFile(absoluteOutputFilePath);
+	}
+	if (!outputSourceFile) return;
+	const modulesDir = project.getDirectory(absoluteModulesDirPath);
+	if (!modulesDir) return;
+	const manifests = upgradeManifestFiles.map((file) => {
+		const filePath = file.getFilePath();
+		const pathParts = filePath.split("/");
+		const upgradesIndex = pathParts.indexOf("upgrades");
+		const documentModelName = upgradesIndex > 0 ? pathParts[upgradesIndex - 1] : "unknown";
+		const moduleSpecifier = modulesDir.getRelativePathAsModuleSpecifierTo(filePath) + ".js";
+		return {
+			originalName: "upgradeManifest",
+			aliasedName: `${camelCase(documentModelName)}UpgradeManifest`,
+			moduleSpecifier
+		};
+	});
+	const existingTypeImport = outputSourceFile.getImportDeclarations().find((imp) => imp.getModuleSpecifierValue() === "document-model" && imp.isTypeOnly());
+	if (existingTypeImport) {
+		if (!existingTypeImport.getNamedImports().some((ni) => ni.getName() === typeName)) existingTypeImport.addNamedImport(typeName);
+	}
+	const existingImports = outputSourceFile.getImportDeclarations();
+	const lastImport = existingImports[existingImports.length - 1];
+	if (lastImport) {
+		const insertText = "\n" + manifests.map(({ originalName, aliasedName, moduleSpecifier }) => `import { ${originalName} as ${aliasedName} } from "${moduleSpecifier}";`).join("\n");
+		const insertPos = lastImport.getEnd();
+		outputSourceFile.insertText(insertPos, insertText);
+	}
+	const variableStatementInput = {
+		isExported: true,
+		declarationKind: VariableDeclarationKind.Const,
+		declarations: [{
+			name: variableName,
+			type: variableType,
+			initializer: `[]`
+		}]
+	};
+	(outputSourceFile.addVariableStatement(variableStatementInput).getDeclarations().at(0)?.getInitializerIfKind(SyntaxKind.ArrayLiteralExpression))?.addElements(manifests.map((m) => m.aliasedName), { useNewLines: true });
+}
+//#endregion
+//#region src/file-builders/document-editor.ts
+/** Generates a document editor for the given `documentModelId` (also called `documentType`) */
+async function tsMorphGenerateDocumentEditor({ packageName, projectDir, editorDir, editorName, editorId, documentModelId }) {
+	const documentModelsDirPath = path$1.join(projectDir, "document-models");
+	const editorsDirPath = path$1.join(projectDir, "editors");
+	const editorDirPath = path$1.join(editorsDirPath, editorDir);
+	const componentsDirPath = path$1.join(editorDirPath, "components");
+	const editorSourceFilesPath = path$1.join(editorsDirPath, "/**/*");
+	const documentModelsSourceFilesPath = path$1.join(documentModelsDirPath, "/**/*");
+	const project = buildTsMorphProject(projectDir);
+	await ensureDirectoriesExist(project, documentModelsDirPath, editorsDirPath, editorDirPath, componentsDirPath);
+	project.addSourceFilesAtPaths(documentModelsSourceFilesPath);
+	project.addSourceFilesAtPaths(editorSourceFilesPath);
+	const documentTypeMetadata = getDocumentTypeMetadata({
+		project,
+		packageName,
+		documentModelId,
+		documentModelsDirPath
+	});
+	const editorVariableNames = getEditorVariableNames(documentTypeMetadata);
+	await makeEditorComponent({
+		project,
+		editorDirPath,
+		...documentTypeMetadata,
+		...editorVariableNames
+	});
+	makeEditorModuleFile({
+		project,
+		editorName,
+		editorId,
+		documentModelId,
+		editorDirPath
+	});
+	await makeEditorsModulesFile(project, projectDir);
+	await project.save();
+}
+async function makeEditorComponent(args) {
+	const { project, editorDirPath } = args;
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, path$1.join(editorDirPath, "editor.tsx"));
+	if (alreadyExists) {
+		const functionDeclaration = sourceFile.getFunction("Editor");
+		if (functionDeclaration) {
+			if (!functionDeclaration.isDefaultExport()) functionDeclaration.setIsDefaultExport(true);
+			return;
+		}
+	}
+	const template = documentEditorEditorFileTemplate(args);
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+//#endregion
+//#region src/file-builders/document-model/gen-dir.ts
+async function makeGenDirFiles(fileMakerArgs) {
+	await makeDocumentModelSchemaIndexFile(fileMakerArgs);
+	await makeDocumentModelGenUtilsFile(fileMakerArgs);
+	await makeDocumentModelGenTypesFile(fileMakerArgs);
+	await makeDocumentModelGenCreatorsFile(fileMakerArgs);
+	await makeDocumentModelGenActionsFile(fileMakerArgs);
+	await makeDocumentModelGenDocumentSchemaFile(fileMakerArgs);
+	await makeDocumentModelGenReducerFile(fileMakerArgs);
+	await makeDocumentModelDocumentTypeFile(fileMakerArgs);
+	await makeDocumentModelGenIndexFile(fileMakerArgs);
+	await makeDocumentModelGenDocumentModelFile(fileMakerArgs);
+	await makeDocumentModelGenPhFactoriesFile(fileMakerArgs);
+	await makeDocumentModelGenControllerFile(fileMakerArgs);
+	const modules = fileMakerArgs.modules;
+	for (const module of modules) {
+		const operationsModuleVariableNames = getDocumentModelOperationsModuleVariableNames(module);
+		await makeGenDirOperationModuleFiles({
+			module,
+			...fileMakerArgs,
+			...operationsModuleVariableNames
+		});
+	}
+}
+async function makeGenDirOperationModuleFiles(fileMakerArgs) {
+	await makeOperationModuleGenActionsFile(fileMakerArgs);
+	await makeOperationModuleGenCreatorsFile(fileMakerArgs);
+	await makeOperationModuleGenOperationsFile(fileMakerArgs);
+	await makeOperationModuleGenErrorFile(fileMakerArgs);
+}
+async function makeDocumentModelGenUtilsFile(args) {
+	const template = documentModelGenUtilsTemplate(args);
+	const { project, genDirPath } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(genDirPath, "utils.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDocumentModelDocumentTypeFile(args) {
+	const template = documentModelDocumentTypeTemplate(args);
+	const { project, genDirPath } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(genDirPath, "document-type.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDocumentModelSchemaIndexFile(args) {
+	const template = documentModelSchemaIndexTemplate;
+	const { project, schemaDirPath } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(schemaDirPath, "index.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDocumentModelGenTypesFile(args) {
+	const template = documentModelGenTypesTemplate(args);
+	const { project, genDirPath } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(genDirPath, "types.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDocumentModelGenDocumentModelFile(args) {
+	const { project, genDirPath, documentModelState } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(genDirPath, "document-model.ts"));
+	sourceFile.replaceWithText("");
+	sourceFile.addImportDeclaration({
+		namedImports: ["DocumentModelGlobalState"],
+		moduleSpecifier: "document-model",
+		isTypeOnly: true
+	});
+	const documentModelStateString = buildObjectLiteral(documentModelState, sourceFile);
+	sourceFile.addVariableStatement({
+		declarationKind: VariableDeclarationKind.Const,
+		isExported: true,
+		declarations: [{
+			name: "documentModel",
+			type: "DocumentModelGlobalState",
+			initializer: documentModelStateString
+		}]
+	});
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDocumentModelGenDocumentSchemaFile(args) {
+	const template = documentModelDocumentSchemaFileTemplate(args);
+	const { project, genDirPath } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(genDirPath, "document-schema.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDocumentModelGenCreatorsFile(args) {
+	const template = documentModelGenCreatorsFileTemplate(args);
+	const { project, genDirPath } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(genDirPath, "creators.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDocumentModelGenPhFactoriesFile(args) {
+	const template = documentModelPhFactoriesFileTemplate(args);
+	const { project, genDirPath } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(genDirPath, "ph-factories.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDocumentModelGenControllerFile(args) {
+	const template = documentModelGenControllerFileTemplate(args);
+	const { project, genDirPath } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(genDirPath, "controller.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDocumentModelGenIndexFile(args) {
+	const template = documentModelGenIndexFileTemplate(args);
+	const { project, genDirPath } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(genDirPath, "index.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDocumentModelGenActionsFile(args) {
+	const template = documentModelGenActionsFileTemplate(args);
+	const { project, genDirPath } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(genDirPath, "actions.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDocumentModelGenReducerFile(args) {
+	const template = documentModelGenReducerFileTemplate(args);
+	const { project, genDirPath } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(genDirPath, "reducer.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeOperationModuleGenActionsFile(args) {
+	const { module } = args;
+	const { actions } = getDocumentModelOperationsModuleVariableNames(module);
+	const pascalCaseModuleName = pascalCase(module.name);
+	const kebabCaseModuleName = kebabCase(module.name);
+	const template = documentModelOperationModuleActionsFileTemplate({
+		...args,
+		actions,
+		pascalCaseModuleName
+	});
+	const { project, genDirPath } = args;
+	const dirPath = path$1.join(genDirPath, kebabCaseModuleName);
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(dirPath, "actions.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeOperationModuleGenCreatorsFile(args) {
+	const { module } = args;
+	const moduleVariableNames = getDocumentModelOperationsModuleVariableNames(module);
+	const kebabCaseModuleName = kebabCase(module.name);
+	const template = documentModelOperationsModuleCreatorsFileTemplate({
+		...args,
+		...moduleVariableNames
+	});
+	const { project, genDirPath } = args;
+	const dirPath = path$1.join(genDirPath, kebabCaseModuleName);
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(dirPath, "creators.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeOperationModuleGenOperationsFile(args) {
+	const { module } = args;
+	const moduleVariableNames = getDocumentModelOperationsModuleVariableNames(module);
+	const kebabCaseModuleName = kebabCase(module.name);
+	const template = documentModelOperationsModuleOperationsFileTemplate({
+		...args,
+		...moduleVariableNames
+	});
+	const { project, genDirPath } = args;
+	const dirPath = path$1.join(genDirPath, kebabCaseModuleName);
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(dirPath, "operations.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeOperationModuleGenErrorFile(args) {
+	const { module } = args;
+	const moduleVariableNames = getDocumentModelOperationsModuleVariableNames(module);
+	const kebabCaseModuleName = kebabCase(module.name);
+	const template = documentModelOperationsModuleErrorFileTemplate({
+		...args,
+		...moduleVariableNames
+	});
+	const { project, genDirPath } = args;
+	const dirPath = path$1.join(genDirPath, kebabCaseModuleName);
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(dirPath, "error.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+//#endregion
+//#region src/file-builders/document-model/migrate-legacy.ts
+/**
+* Detects whether a document model directory has a legacy (non-versioned)
+* structure and migrates it to the versioned layout expected by `--use-versioning`.
+*
+* Detection: a directory is "legacy" when `src/reducers/` exists at root level
+* AND no `v1/` directory exists yet.
+*
+* Migration steps:
+* 1. Move legacy root-level items (`gen/`, `src/`, `tests/`, and known root files)
+*    into a `legacy/` subfolder for reference / backup.
+* 2. Copy custom source files (reducers, tests, utils) from `legacy/` into the
+*    soon-to-be-created `v1/` directory so that ts-morph picks them up during
+*    generation and preserves business logic.
+*
+* This function is idempotent — calling it on an already-migrated directory is a
+* no-op.
+*/
+async function migrateLegacyToVersioned(documentModelDirPath) {
+	const srcReducersPath = path$1.join(documentModelDirPath, "src", "reducers");
+	const v1Path = path$1.join(documentModelDirPath, "v1");
+	const legacyPath = path$1.join(documentModelDirPath, "legacy");
+	const hasSrcReducers = await directoryExists(srcReducersPath);
+	const hasV1 = await directoryExists(v1Path);
+	if (!hasSrcReducers || hasV1) return;
+	console.log(`[migrate-legacy] Detected legacy structure in ${documentModelDirPath}`);
+	await mkdir(legacyPath, { recursive: true });
+	const dirsToMove = [
+		"gen",
+		"src",
+		"tests"
+	];
+	const filesToMove = [
+		"module.ts",
+		"actions.ts",
+		"hooks.ts",
+		"utils.ts",
+		"index.ts",
+		"schema.graphql"
+	];
+	for (const dirName of dirsToMove) {
+		const srcPath = path$1.join(documentModelDirPath, dirName);
+		if (await directoryExists(srcPath)) {
+			await rename(srcPath, path$1.join(legacyPath, dirName));
+			console.log(`[migrate-legacy] Moved ${dirName}/ → legacy/${dirName}/`);
+		}
+	}
+	for (const fileName of filesToMove) {
+		const srcPath = path$1.join(documentModelDirPath, fileName);
+		if (await fileExists(srcPath)) {
+			await rename(srcPath, path$1.join(legacyPath, fileName));
+			console.log(`[migrate-legacy] Moved ${fileName} → legacy/${fileName}`);
+		}
+	}
+	const v1SrcReducersPath = path$1.join(v1Path, "src", "reducers");
+	const v1SrcPath = path$1.join(v1Path, "src");
+	const v1TestsPath = path$1.join(v1Path, "tests");
+	const legacySrcReducersPath = path$1.join(legacyPath, "src", "reducers");
+	if (await directoryExists(legacySrcReducersPath)) {
+		await mkdir(v1SrcReducersPath, { recursive: true });
+		await copyDirectoryFiles(legacySrcReducersPath, v1SrcReducersPath);
+		console.log(`[migrate-legacy] Copied src/reducers/ → v1/src/reducers/`);
+	}
+	const legacySrcTestsPath = path$1.join(legacyPath, "src", "tests");
+	if (await directoryExists(legacySrcTestsPath)) {
+		const v1SrcTestsPath = path$1.join(v1SrcPath, "tests");
+		await mkdir(v1SrcTestsPath, { recursive: true });
+		await copyDirectoryFiles(legacySrcTestsPath, v1SrcTestsPath);
+		console.log(`[migrate-legacy] Copied src/tests/ → v1/src/tests/`);
+	}
+	const legacyTestsPath = path$1.join(legacyPath, "tests");
+	if (await directoryExists(legacyTestsPath)) {
+		await mkdir(v1TestsPath, { recursive: true });
+		await copyDirectoryFiles(legacyTestsPath, v1TestsPath);
+		console.log(`[migrate-legacy] Copied tests/ → v1/tests/`);
+	}
+	const legacyUtilsPath = path$1.join(legacyPath, "src", "utils.ts");
+	if (await fileExists(legacyUtilsPath)) {
+		await mkdir(v1SrcPath, { recursive: true });
+		await copyFile(legacyUtilsPath, path$1.join(v1SrcPath, "utils.ts"));
+		console.log(`[migrate-legacy] Copied src/utils.ts → v1/src/utils.ts`);
+	}
+	console.log(`[migrate-legacy] Migration complete for ${documentModelDirPath}`);
+}
+/** Copy all files (non-recursive) from srcDir to destDir */
+async function copyDirectoryFiles(srcDir, destDir) {
+	const entries = await readdir(srcDir, { withFileTypes: true });
+	for (const entry of entries) if (entry.isFile()) await copyFile(path$1.join(srcDir, entry.name), path$1.join(destDir, entry.name));
+}
+//#endregion
+//#region src/file-builders/document-model/root-dir.ts
+async function makeRootDirFiles(fileMakerArgs) {
+	await makeDocumentModelVersionIndexFile(fileMakerArgs);
+	await makeDocumentModelRootActionsFile(fileMakerArgs);
+	await makeDocumentModelModuleFile(fileMakerArgs);
+	await makeDocumentModelUtilsFile(fileMakerArgs);
+	await makeDocumentModelHooksFile(fileMakerArgs);
+}
+async function makeDocumentModelVersionIndexFile(args) {
+	const template = documentModelIndexTemplate;
+	const { project, documentModelVersionDirPath } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(documentModelVersionDirPath, "index.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDocumentModelUtilsFile(args) {
+	const template = documentModelUtilsTemplate(args);
+	const { project, documentModelVersionDirPath } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(documentModelVersionDirPath, "utils.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDocumentModelRootActionsFile(args) {
+	const template = documentModelRootActionsFileTemplate(args);
+	const { project, documentModelVersionDirPath } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(documentModelVersionDirPath, "actions.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDocumentModelHooksFile(args) {
+	const template = documentModelHooksFileTemplate(args);
+	const { project, documentModelVersionDirPath } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(documentModelVersionDirPath, "hooks.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDocumentModelModuleFile(args) {
+	const { project, documentModelVersionDirPath } = args;
+	const template = documentModelModuleFileTemplate(args);
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(documentModelVersionDirPath, "module.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+//#endregion
+//#region src/file-builders/document-model/src-dir.ts
+async function makeSrcDirFiles(fileMakerArgs) {
+	await makeDocumentModelSrcIndexFile(fileMakerArgs);
+	await makeDocumentModelSrcUtilsFile(fileMakerArgs);
+	await makeReducerOperationHandlersForModules(fileMakerArgs);
+}
+async function makeReducerOperationHandlersForModules(fileMakerArgs) {
+	const { modules } = fileMakerArgs;
+	for (const module of modules) await makeReducerOperationHandlerForModule({
+		...fileMakerArgs,
+		module
+	});
+}
+async function makeReducerOperationHandlerForModule({ project, module, version, reducersDirPath, pascalCaseDocumentType, camelCaseDocumentType, versionedDocumentModelPackageImportPath }) {
+	const kebabCaseModuleName = kebabCase(module.name);
+	const pascalCaseModuleName = pascalCase(module.name);
+	const filePath = path$1.join(reducersDirPath, `${kebabCaseModuleName}.ts`);
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, filePath);
+	if (!alreadyExists) {
+		const previousVersionFile = getPreviousVersionSourceFile({
+			project,
+			version,
+			filePath
+		});
+		if (previousVersionFile) sourceFile.replaceWithText(previousVersionFile.getText());
+	}
+	const operationsInterfaceTypeName = `${pascalCaseDocumentType}${pascalCaseModuleName}Operations`;
+	const operationsInterfaceVariableName = `${camelCaseDocumentType}${pascalCaseModuleName}Operations`;
+	const existingOperationsInterfaceTypeImport = sourceFile.getImportDeclaration((importDeclaration) => !!importDeclaration.getNamedImports().find((importSpecifier) => importSpecifier.getName() === operationsInterfaceTypeName));
+	if (existingOperationsInterfaceTypeImport) existingOperationsInterfaceTypeImport.remove();
+	const operationsInterfaceTypeProperties = sourceFile.addImportDeclaration({
+		namedImports: [operationsInterfaceTypeName],
+		moduleSpecifier: versionedDocumentModelPackageImportPath,
+		isTypeOnly: true
+	}).getNamedImports().find((value) => value.getName() === operationsInterfaceTypeName)?.getNameNode().getType().getProperties().map((symbol) => symbol.getName());
+	if (!operationsInterfaceTypeProperties) throw new Error("Failed to create operation handler object");
+	let operationsInterfaceVariableStatement = sourceFile.getVariableStatement(operationsInterfaceVariableName);
+	if (!operationsInterfaceVariableStatement) operationsInterfaceVariableStatement = sourceFile.addVariableStatement({
+		declarationKind: VariableDeclarationKind.Const,
+		isExported: true,
+		declarations: [{
+			name: operationsInterfaceVariableName,
+			type: operationsInterfaceTypeName,
+			initializer: "{}"
+		}]
+	});
+	const operationsInterfaceObject = getObjectLiteral(operationsInterfaceVariableStatement);
+	if (!operationsInterfaceObject) throw new Error("Failed to build reducer object");
+	const operationsByMethodName = /* @__PURE__ */ new Map();
+	for (const operation of module.operations) if (operation.name) {
+		const methodName = `${camelCase(operation.name)}Operation`;
+		operationsByMethodName.set(methodName, operation);
+	}
+	for (const name of operationsInterfaceTypeProperties) {
+		if (operationsInterfaceObject.getProperty(name)) continue;
+		const reducerCode = operationsByMethodName.get(name)?.reducer?.trim();
+		operationsInterfaceObject.addMethod({
+			name,
+			parameters: [{ name: "state" }, { name: "action" }],
+			statements: reducerCode ? [reducerCode] : [`// TODO: implement ${name} reducer`, ts`throw new Error("Reducer for '${name}' not implemented.")`.raw]
+		});
+	}
+	addErrorImportsForModule(sourceFile, module);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDocumentModelSrcIndexFile({ project, ...variableNames }) {
+	const template = documentModelSrcIndexFileTemplate;
+	const { srcDirPath } = variableNames;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(srcDirPath, "index.ts"));
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDocumentModelSrcUtilsFile({ project, srcDirPath, version }) {
+	const template = documentModelSrcUtilsTemplate;
+	const filePath = path$1.join(srcDirPath, "utils.ts");
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, filePath);
+	if (!alreadyExists) {
+		const previousVersionSourceFile = getPreviousVersionSourceFile({
+			project,
+			version,
+			filePath
+		});
+		if (previousVersionSourceFile) sourceFile.replaceWithText(previousVersionSourceFile.getText());
+		else sourceFile.replaceWithText(template);
+	}
+	await formatSourceFileWithPrettier(sourceFile);
+}
+function addErrorImportsForModule(sourceFile, module) {
+	const allErrors = [];
+	for (const operation of module.operations) if (Array.isArray(operation.errors)) {
+		for (const error of operation.errors) if (error.name && !allErrors.find((e) => e.name === error.name)) allErrors.push({ name: error.name });
+	}
+	if (allErrors.length === 0) return;
+	const sourceFileContent = sourceFile.getFullText();
+	const usedErrors = [];
+	for (const error of allErrors) if (new RegExp(`\\b${error.name}\\b`, "g").test(sourceFileContent)) usedErrors.push(error.name);
+	if (usedErrors.length === 0) return;
+	const errorImportPath = `../../gen/${kebabCase(module.name)}/error.js`;
+	const existingErrorImport = sourceFile.getImportDeclarations().find((importDecl) => importDecl.getModuleSpecifierValue() === errorImportPath);
+	if (existingErrorImport) {
+		const existingNamedImports = existingErrorImport.getNamedImports().map((namedImport) => namedImport.getName());
+		const newErrorsToImport = usedErrors.filter((errorName) => !existingNamedImports.includes(errorName));
+		if (newErrorsToImport.length > 0) existingErrorImport.addNamedImports(newErrorsToImport);
+	} else sourceFile.addImportDeclaration({
+		namedImports: usedErrors,
+		moduleSpecifier: errorImportPath
+	});
+}
+//#endregion
+//#region src/file-builders/document-model/tests-dir.ts
+async function makeTestsDirFiles(fileMakerArgs) {
+	await makeDocumentModelTestFile(fileMakerArgs);
+	const modules = fileMakerArgs.modules;
+	for (const module of modules) await makeOperationModuleTestFile({
+		...fileMakerArgs,
+		module
+	});
+}
+async function makeOperationModuleTestFile(args) {
+	const { project, module, version, testsDirPath, documentModelPackageImportPath, versionedDocumentModelPackageImportPath, isPhDocumentOfTypeFunctionName } = args;
+	const moduleVariableNames = getDocumentModelOperationsModuleVariableNames(module);
+	const { actions } = moduleVariableNames;
+	const kebabCaseModuleName = kebabCase(module.name);
+	const moduleOperationsTypeName = `${pascalCase(module.name)}Operations`;
+	const filePath = path$1.join(testsDirPath, `${kebabCaseModuleName}.test.ts`);
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, filePath);
+	if (!alreadyExists) {
+		const previousVersionSourceFile = getPreviousVersionSourceFile({
+			project,
+			version,
+			filePath
+		});
+		if (previousVersionSourceFile) sourceFile.replaceWithText(previousVersionSourceFile.getText());
+		else sourceFile.replaceWithText(ts`
+        import { generateMock } from "document-model";
+        import { describe, expect, it } from "vitest";
+
+        describe("${moduleOperationsTypeName}", () => {
+
+        });
+        `.raw);
+	}
+	const importNames = makeActionImportNames({
+		...args,
+		...moduleVariableNames
+	});
+	const namedImports = importNames.map((name) => ({ name }));
+	let actionsImportDeclaration = sourceFile.getImportDeclarations().filter((i) => !i.isTypeOnly()).find((importDeclaration) => importDeclaration.getModuleSpecifier().getText().includes(documentModelPackageImportPath));
+	if (!actionsImportDeclaration) actionsImportDeclaration = sourceFile.addImportDeclaration({
+		namedImports,
+		moduleSpecifier: versionedDocumentModelPackageImportPath
+	});
+	else {
+		actionsImportDeclaration.setModuleSpecifier(versionedDocumentModelPackageImportPath);
+		const existingNamedImports = actionsImportDeclaration.getNamedImports().map((value) => value.getName());
+		for (const name of importNames) if (!existingNamedImports.includes(name)) actionsImportDeclaration.addNamedImport(name);
+	}
+	const describeCall = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((call) => {
+		const expressionText = call.getExpression().getText();
+		const firstArg = call.getArguments()[0];
+		return expressionText === "describe" && pascalCase(firstArg.getText()).includes(moduleOperationsTypeName);
+	});
+	if (!describeCall) {
+		console.error(`Test file at path ${filePath} has no describe block for ${moduleOperationsTypeName}`);
+		return;
+	}
+	const describeCallBody = describeCall.getArguments()[1].asKindOrThrow(SyntaxKind.ArrowFunction);
+	const testCaseNames = describeCall.getDescendantsOfKind(SyntaxKind.CallExpression).filter((call) => {
+		const expressionText = call.getExpression().getText();
+		return expressionText === "it" || expressionText === "test";
+	}).map((c) => c.getArguments()[0].getText());
+	const testCasesToAdd = actions.filter((action) => {
+		const camelCaseActionName = camelCase(action.name);
+		return !testCaseNames.some((c) => c.includes(camelCaseActionName));
+	}).map((action) => makeTestCaseForAction(action, isPhDocumentOfTypeFunctionName));
+	describeCallBody.addStatements(testCasesToAdd);
+	const GENERATE_MOCK_NAME = "generateMock";
+	const GENERATE_MOCK_MODULE_SPECIFIER = "@powerhousedao/codegen";
+	const generateMockImport = sourceFile.getImportDeclaration((i) => i.getNamedImports().some((v) => v.getText().includes(GENERATE_MOCK_NAME)));
+	if (sourceFile.getText().includes(GENERATE_MOCK_NAME) && !generateMockImport) sourceFile.addImportDeclaration({
+		namedImports: [GENERATE_MOCK_NAME],
+		moduleSpecifier: GENERATE_MOCK_MODULE_SPECIFIER
+	});
+	sourceFile.fixUnusedIdentifiers();
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDocumentModelTestFile(args) {
+	const { project, testsDirPath } = args;
+	const template = documentModelTestFileTemplate(args);
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, path$1.join(testsDirPath, "document-model.test.ts"));
+	if (alreadyExists) return;
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+//#endregion
+//#region src/file-builders/document-model/upgrades-dir.ts
+async function makeUpgradeFile(args) {
+	const { project, version, upgradesDirPath, documentModelPackageImportPath, phStateName } = args;
+	if (version < 2) return;
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, path$1.join(upgradesDirPath, `v${version}.ts`));
+	if (alreadyExists) return;
+	const template = upgradeTransitionTemplate({
+		version,
+		previousVersion: version - 1,
+		documentModelPackageImportPath,
+		phStateName
+	});
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function createOrUpdateUpgradeManifestFile(args) {
+	const { project, specVersions, upgradesDirPath, documentModelId, upgradeManifestName } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(upgradesDirPath, "upgrade-manifest.ts"));
+	const template = upgradeManifestTemplate({
+		documentModelId,
+		upgradeManifestName
+	});
+	sourceFile.replaceWithText(template);
+	const upgradeTransitionImports = buildUpgradeTransitionImports(specVersions);
+	sourceFile.addImportDeclarations(upgradeTransitionImports);
+	const upgradeManifestStatement = getVariableDeclarationByTypeName(sourceFile, "UpgradeManifest")?.getVariableStatementOrThrow();
+	const upgradesProperty = getObjectLiteral(upgradeManifestStatement)?.getProperty("upgrades");
+	const upgrades = buildUpgrades(specVersions);
+	upgradesProperty?.replaceWithText(upgrades);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+function buildUpgrades(specVersions) {
+	const upgradeStrings = [];
+	for (const version of specVersions) {
+		if (version < 2) continue;
+		upgradeStrings.push(`v${version}`);
+	}
+	return `upgrades: { ${upgradeStrings.join(",\n")} }`;
+}
+function buildUpgradeTransitionImports(specVersions) {
+	const imports = [];
+	for (const version of specVersions) {
+		if (version < 2) continue;
+		const namedImports = [`v${version}`];
+		const moduleSpecifier = `./v${version}.js`;
+		imports.push({
+			namedImports,
+			moduleSpecifier
+		});
+	}
+	return imports;
+}
+async function createOrUpdateVersionConstantsFile({ specVersions, latestVersion, project, upgradesDirPath }) {
+	const SUPPORTED_VERSIONS = "supportedVersions";
+	const LATEST_VERSION = "latestVersion";
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(upgradesDirPath, "versions.ts"));
+	sourceFile.replaceWithText("");
+	const latestVersionIndex = specVersions.indexOf(latestVersion);
+	const versionInitializer = `[${specVersions.join(", ")}] as const;`;
+	const latestInitializer = `${SUPPORTED_VERSIONS}[${latestVersionIndex}];`;
+	sourceFile.addVariableStatement({
+		declarationKind: VariableDeclarationKind.Const,
+		isExported: true,
+		declarations: [{
+			name: SUPPORTED_VERSIONS,
+			initializer: versionInitializer
+		}]
+	});
+	sourceFile.addVariableStatement({
+		declarationKind: VariableDeclarationKind.Const,
+		isExported: true,
+		declarations: [{
+			name: LATEST_VERSION,
+			initializer: latestInitializer
+		}]
+	});
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeUpgradesIndexFile({ project, upgradesDirPath, specVersions, upgradeManifestName }) {
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(upgradesDirPath, "index.ts"));
+	sourceFile.replaceWithText("");
+	const upgradeReducerExports = makeUpgradeReducerExports(specVersions);
+	sourceFile.addExportDeclarations([
+		{
+			namedExports: [upgradeManifestName],
+			moduleSpecifier: "./upgrade-manifest.js"
+		},
+		{
+			namedExports: ["supportedVersions", "latestVersion"],
+			moduleSpecifier: "./versions.js"
+		},
+		...upgradeReducerExports
+	]);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+function makeUpgradeReducerExports(specVersions) {
+	const exports = [];
+	for (const version of specVersions) {
+		if (version < 2) continue;
+		const namedExports = [`v${version}`];
+		const moduleSpecifier = `./v${version}.js`;
+		exports.push({
+			namedExports,
+			moduleSpecifier
+		});
+	}
+	return exports;
+}
+//#endregion
+//#region src/file-builders/document-model/document-model.ts
+/** Generates a document model from the given `documentModelState`
+*
+* If `useVersioning` is set to true, it will generate versioned document model code
+* for each `specification` in the `documentModelState`
+*/
+async function tsMorphGenerateDocumentModel({ projectDir, packageName, documentModelState, useVersioning, migrateLegacy }) {
+	if (migrateLegacy) await migrateLegacyToVersioned(path$1.join(projectDir, "document-models", getDocumentModelDirName(documentModelState)));
+	const project = buildTsMorphProject(projectDir);
+	const documentModelsSourceFilesPath = path$1.join(projectDir, "document-models/**/*");
+	const documentModelsDirPath = path$1.join(projectDir, "document-models");
+	const documentModelDirName = getDocumentModelDirName(documentModelState);
+	const documentModelDirPath = path$1.join(documentModelsDirPath, documentModelDirName);
+	const upgradesDirPath = path$1.join(documentModelDirPath, "upgrades");
+	const documentModelVariableNames = getDocumentModelVariableNames(documentModelState.name);
+	await ensureDirectoriesExist(project, documentModelsDirPath, documentModelDirPath);
+	if (useVersioning) await ensureDirectoriesExist(project, upgradesDirPath);
+	project.addSourceFilesAtPaths(documentModelsSourceFilesPath);
+	const documentModelPackageImportPath = path$1.join("document-models", documentModelDirName);
+	const specVersions = [...new Set([...documentModelState.specifications.map((spec) => spec.version)])].toSorted();
+	if (specVersions.length !== documentModelState.specifications.length) throw new Error("Document model specifications array is misconfigured. Length is not match with spec versions.");
+	const latestVersion = specVersions[specVersions.length - 1];
+	if (documentModelState.specifications[documentModelState.specifications.length - 1].version !== latestVersion) throw new Error("Document model has incorrect version at the latest version index");
+	await writeDocumentModelStateJsonFile({
+		documentModelState,
+		documentModelDirName,
+		documentModelDirPath
+	});
+	if (useVersioning) {
+		await Promise.all(specVersions.map(async (version) => await generateDocumentModelForSpec({
+			project,
+			version,
+			useVersioning: true,
+			packageName,
+			documentModelState,
+			projectDir,
+			documentModelsDirPath,
+			documentModelDirName,
+			documentModelDirPath,
+			documentModelPackageImportPath,
+			...documentModelVariableNames
+		})));
+		for (const version of specVersions) await makeUpgradeFile({
+			version,
+			upgradesDirPath,
+			project,
+			documentModelPackageImportPath,
+			...documentModelVariableNames
+		});
+		await makeDocumentModelIndexFile({
+			project,
+			documentModelDirPath,
+			latestVersion
+		});
+		await createOrUpdateVersionConstantsFile({
+			project,
+			specVersions,
+			latestVersion,
+			upgradesDirPath
+		});
+		await createOrUpdateUpgradeManifestFile({
+			project,
+			specVersions,
+			latestVersion,
+			upgradesDirPath,
+			documentModelId: documentModelState.id,
+			...documentModelVariableNames
+		});
+		await makeUpgradesIndexFile({
+			project,
+			upgradesDirPath,
+			specVersions,
+			...documentModelVariableNames
+		});
+	} else await generateDocumentModelForSpec({
+		project,
+		useVersioning: false,
+		version: latestVersion,
+		packageName,
+		documentModelState,
+		projectDir,
+		documentModelsDirPath,
+		documentModelDirName,
+		documentModelDirPath,
+		documentModelPackageImportPath,
+		...documentModelVariableNames
+	});
+	await project.save();
+}
+/** Generates document model code for a given `specification` from a `documentModelState` object */
+async function generateDocumentModelForSpec({ project, projectDir, packageName, documentModelState, documentModelPackageImportPath, documentModelsDirPath, documentModelDirName, documentModelDirPath, useVersioning, version, ...documentModelVariableNames }) {
+	const specification = documentModelState.specifications.find((spec) => spec.version === version);
+	if (!specification) throw new Error(`Document model specifications array is misconfigured, no specification found for version: ${version}`);
+	const versionDirName = useVersioning ? `v${version}` : "";
+	const documentModelVersionDirName = path$1.join(documentModelDirName, versionDirName);
+	const documentModelVersionDirPath = path$1.join(documentModelDirPath, versionDirName);
+	const versionedDocumentModelPackageImportPath = path$1.join(documentModelPackageImportPath, versionDirName);
+	const fileExtension = documentModelState.extension;
+	const documentTypeId = documentModelState.id;
+	const srcDirPath = path$1.join(documentModelVersionDirPath, "src");
+	const reducersDirPath = path$1.join(srcDirPath, "reducers");
+	const testsDirPath = path$1.join(documentModelVersionDirPath, "tests");
+	const genDirPath = path$1.join(documentModelVersionDirPath, "gen");
+	const schemaDirPath = path$1.join(genDirPath, "schema");
+	const { initialGlobalState, initialLocalState } = getInitialStates(specification.state);
+	const hasLocalSchema = specification.state.local.schema !== "";
+	const modules = specification.modules;
+	await ensureDirectoriesExist(project, documentModelVersionDirPath, reducersDirPath, testsDirPath, schemaDirPath, ...modules.map((module) => path$1.join(genDirPath, kebabCase(module.name))));
+	const fileMakerArgs = {
+		project,
+		projectDir,
+		packageName,
+		version,
+		useVersioning,
+		documentTypeId,
+		documentModelState,
+		initialGlobalState,
+		initialLocalState,
+		modules,
+		hasLocalSchema,
+		documentModelsDirPath,
+		documentModelDirPath,
+		documentModelDirName,
+		documentModelVersionDirName,
+		documentModelVersionDirPath,
+		documentModelPackageImportPath,
+		versionedDocumentModelPackageImportPath,
+		srcDirPath,
+		genDirPath,
+		testsDirPath,
+		schemaDirPath,
+		reducersDirPath,
+		fileExtension,
+		...documentModelVariableNames
+	};
+	await generateDocumentModelZodSchemas({
+		documentModelDirPath: documentModelVersionDirPath,
+		specification
+	});
+	await makeRootDirFiles(fileMakerArgs);
+	await makeGenDirFiles(fileMakerArgs);
+	await makeSrcDirFiles(fileMakerArgs);
+	await makeTestsDirFiles(fileMakerArgs);
+	await makeDocumentModelModulesFile(fileMakerArgs);
+	if (!useVersioning) return;
+	await makeUpgradeManifestsFile({
+		project,
+		projectDir
+	});
+	const previousVersionDirPath = getPreviousVersionDirPath(documentModelDirPath, version);
+	if (!previousVersionDirPath) return;
+	await persistCustomFilesFromPreviousVersion({
+		currentVersionDirPath: documentModelVersionDirPath,
+		previousVersionDirPath
+	});
+}
+/** Writes a json file derived from a `documentModelState` */
+async function writeDocumentModelStateJsonFile({ documentModelState, documentModelDirName, documentModelDirPath }) {
+	await writeFile(path$1.join(documentModelDirPath, `${documentModelDirName}.json`), JSON.stringify(documentModelState, null, 2));
+}
+function getPreviousVersionDirPath(documentModelDirPath, version) {
+	const previousVersion = version - 1;
+	if (previousVersion < 1) return;
+	const previousVersionDirName = `v${previousVersion}`;
+	return path$1.join(documentModelDirPath, previousVersionDirName);
+}
+async function makeDocumentModelIndexFile(args) {
+	const { project, documentModelDirPath, latestVersion } = args;
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(documentModelDirPath, "index.ts"));
+	sourceFile.replaceWithText("");
+	sourceFile.addExportDeclarations([{ moduleSpecifier: `./v${latestVersion}/index.js` }, { moduleSpecifier: `./upgrades/index.js` }]);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function persistCustomFilesFromPreviousVersion(args) {
+	const { currentVersionDirPath, previousVersionDirPath } = args;
+	if (!await directoryExists(previousVersionDirPath)) return;
+	const previousVersionFiles = (await readdir(previousVersionDirPath, {
+		withFileTypes: true,
+		recursive: true
+	})).filter((dirEnt) => dirEnt.isFile()).map(({ name, parentPath }) => ({
+		name,
+		parentPath,
+		relativePath: path$1.relative(previousVersionDirPath, parentPath)
+	}));
+	for (const { name, relativePath } of previousVersionFiles) {
+		const filePathInCurrentVersionDir = path$1.join(currentVersionDirPath, relativePath, name);
+		const filePathInPreviousVersionDir = path$1.join(previousVersionDirPath, relativePath, name);
+		const existsInPreviousVersionDir = await fileExists(filePathInPreviousVersionDir);
+		const existsInCurrentVersionDir = await fileExists(filePathInCurrentVersionDir);
+		if (existsInPreviousVersionDir && !existsInCurrentVersionDir) {
+			console.log(`Persisting file "${path$1.join(relativePath, name)}" from previous version directory.`);
+			await mkdir(path$1.join(currentVersionDirPath, relativePath), { recursive: true });
+			await copyFile(filePathInPreviousVersionDir, filePathInCurrentVersionDir);
+		}
+	}
+}
+//#endregion
+//#region src/file-builders/drive-editor.ts
+/** Generates a drive editor with the configs for `allowedDocumentModelIds` and `isDragAndDropEnabled` */
+async function tsMorphGenerateDriveEditor({ projectDir, editorDir, editorName, editorId, allowedDocumentModelIds, isDragAndDropEnabled }) {
+	const documentModelsDirPath = path$1.join(projectDir, "document-models");
+	const documentModelsSourceFilesPath = path$1.join(documentModelsDirPath, "/**/*");
+	const editorsDirPath = path$1.join(projectDir, "editors");
+	const editorSourceFilesPath = path$1.join(editorsDirPath, "/**/*");
+	const editorDirPath = path$1.join(editorsDirPath, editorDir);
+	const editorComponentsDirPath = path$1.join(editorDirPath, "components");
+	const project = buildTsMorphProject(projectDir);
+	await ensureDirectoriesExist(project, documentModelsDirPath, editorsDirPath, editorDirPath, editorComponentsDirPath);
+	project.addSourceFilesAtPaths(documentModelsSourceFilesPath);
+	project.addSourceFilesAtPaths(editorSourceFilesPath);
+	await makeNavigationBreadcrumbsFile({
+		project,
+		editorComponentsDirPath
+	});
+	await makeCreateDocumentFile({
+		project,
+		editorComponentsDirPath
+	});
+	await makeEmptyStateFile({
+		project,
+		editorComponentsDirPath
+	});
+	await makeFoldersFile({
+		project,
+		editorComponentsDirPath
+	});
+	await makeFolderTreeFile({
+		project,
+		editorComponentsDirPath
+	});
+	await makeFilesFile({
+		project,
+		editorComponentsDirPath
+	});
+	await makeDriveExplorerFile({
+		project,
+		editorComponentsDirPath
+	});
+	await makeDriveContentsFile({
+		project,
+		editorComponentsDirPath
+	});
+	await makeDriveEditorComponent({
+		project,
+		editorDirPath
+	});
+	await makeDriveEditorConfigFile({
+		project,
+		allowedDocumentModelIds,
+		isDragAndDropEnabled,
+		editorDirPath
+	});
+	makeEditorModuleFile({
+		project,
+		editorName,
+		editorId,
+		editorDirPath,
+		documentModelId: "powerhouse/document-drive"
+	});
+	await makeEditorsModulesFile(project, projectDir);
+	await project.save();
+}
+async function makeDriveEditorComponent({ project, editorDirPath }) {
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, path$1.join(editorDirPath, "editor.tsx"));
+	if (alreadyExists) {
+		const editorFunction = sourceFile.getFunction("Editor");
+		if (editorFunction) {
+			if (!editorFunction.isDefaultExport()) editorFunction.setIsDefaultExport(true);
+			return;
+		}
+	}
+	const template = driveEditorEditorFileTemplate();
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDriveEditorConfigFile({ project, editorDirPath, allowedDocumentModelIds, isDragAndDropEnabled }) {
+	const { sourceFile } = getOrCreateSourceFile(project, path$1.join(editorDirPath, "config.ts"));
+	const allowedDocumentTypesString = JSON.stringify(allowedDocumentModelIds);
+	const template = driveEditorConfigFileTemplate({
+		isDragAndDropEnabledString: isDragAndDropEnabled ? "true" : "false",
+		allowedDocumentTypesString
+	});
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDriveContentsFile({ project, editorComponentsDirPath }) {
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, path$1.join(editorComponentsDirPath, "DriveContents.tsx"));
+	if (alreadyExists) return;
+	const template = driveEditorDriveContentsFileTemplate();
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeNavigationBreadcrumbsFile({ project, editorComponentsDirPath }) {
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, path$1.join(editorComponentsDirPath, "NavigationBreadcrumbs.tsx"));
+	if (alreadyExists) return;
+	sourceFile.replaceWithText(driveExplorerNavigationBreadcrumbsFileTemplate());
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeFoldersFile({ project, editorComponentsDirPath }) {
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, path$1.join(editorComponentsDirPath, "Folders.tsx"));
+	if (alreadyExists) return;
+	const template = driveEditorFoldersFileTemplate();
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeFilesFile({ project, editorComponentsDirPath }) {
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, path$1.join(editorComponentsDirPath, "Files.tsx"));
+	if (alreadyExists) return;
+	const template = driveEditorFilesFileTemplate();
+	sourceFile.replaceWithText(template);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeDriveExplorerFile({ project, editorComponentsDirPath }) {
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, path$1.join(editorComponentsDirPath, "DriveExplorer.tsx"));
+	if (alreadyExists) return;
+	sourceFile.replaceWithText(driveExplorerFileTemplate);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeFolderTreeFile({ project, editorComponentsDirPath }) {
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, path$1.join(editorComponentsDirPath, "FolderTree.tsx"));
+	if (alreadyExists) return;
+	sourceFile.replaceWithText(folderTreeFileTemplate);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeEmptyStateFile({ project, editorComponentsDirPath }) {
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, path$1.join(editorComponentsDirPath, "EmptyState.tsx"));
+	if (alreadyExists) return;
+	sourceFile.replaceWithText(emptyStateFileTemplate);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeCreateDocumentFile({ project, editorComponentsDirPath }) {
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, path$1.join(editorComponentsDirPath, "CreateDocument.tsx"));
+	if (alreadyExists) return;
+	sourceFile.replaceWithText(createDocumentFileTemplate);
+	await formatSourceFileWithPrettier(sourceFile);
+}
+//#endregion
+//#region src/file-builders/subgraph.ts
+async function tsMorphGenerateSubgraph(args) {
+	const { subgraphsDir, subgraphName, packageName, documentModel } = args;
+	const project = new Project({
+		skipAddingFilesFromTsConfig: true,
+		skipLoadingLibFiles: true
+	});
+	const kebabCaseName = kebabCase(subgraphName);
+	const pascalCaseName = pascalCase(subgraphName);
+	const camelCaseName = camelCase(subgraphName);
+	const subgraphDir = path$1.join(subgraphsDir, kebabCaseName);
+	if (existsSync(subgraphDir)) for (const name of [
+		"index.ts",
+		"lib.ts",
+		"schema.ts",
+		"resolvers.ts"
+	]) {
+		const filePath = path$1.join(subgraphDir, name);
+		if (existsSync(filePath)) project.addSourceFileAtPath(filePath);
+	}
+	await makeBaseSubgraphIndexFile(project, subgraphDir, {
+		pascalCaseName,
+		kebabCaseName
+	});
+	await makeBaseSubgraphLibFile(project, subgraphDir);
+	if (documentModel !== null) await makeDocumentModelSubgraphFiles(project, subgraphDir, {
+		documentModel,
+		packageName
+	});
+	else await makeCustomSubgraphFiles(project, subgraphDir, {
+		pascalCaseName,
+		camelCaseName
+	});
+	await project.save();
+}
+async function makeBaseSubgraphIndexFile(project, dirPath, v) {
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, path$1.join(dirPath, "index.ts"));
+	if (alreadyExists) return;
+	sourceFile.replaceWithText(subgraphIndexFileTemplate(v));
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeBaseSubgraphLibFile(project, dirPath) {
+	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, path$1.join(dirPath, "lib.ts"));
+	if (alreadyExists) return;
+	sourceFile.replaceWithText(subgraphLibFileTemplate());
+	await formatSourceFileWithPrettier(sourceFile);
+}
+async function makeCustomSubgraphFiles(project, dirPath, v) {
+	const schema = getOrCreateSourceFile(project, path$1.join(dirPath, "schema.ts"));
+	if (!schema.alreadyExists) schema.sourceFile.replaceWithText(customSubgraphSchemaTemplate(v));
+	const resolvers = getOrCreateSourceFile(project, path$1.join(dirPath, "resolvers.ts"));
+	if (!resolvers.alreadyExists) {
+		resolvers.sourceFile.replaceWithText(customSubgraphResolversTemplate(v));
+		await formatSourceFileWithPrettier(resolvers.sourceFile);
+	}
+}
+async function makeDocumentModelSubgraphFiles(project, dirPath, args) {
+	const { documentModel, packageName } = args;
+	const latestSpec = documentModel.specifications[documentModel.specifications.length - 1];
+	const documentType = documentModel.name;
+	const pascalCaseDocumentType = pascalCase(documentType);
+	const camelCaseDocumentType = camelCase(documentType);
+	const phDocumentTypeName = `${pascalCaseDocumentType}Document`;
+	const documentTypeVariableName = `${camelCaseDocumentType}DocumentType`;
+	const documentModelDir = `${packageName}/document-models/${kebabCase(documentType)}`;
+	const stateSchema = latestSpec.state.global.schema;
+	const stateTypeNames = extractTypeNames(stateSchema);
+	const modules = latestSpec.modules.filter((m) => m.name !== null).map((m) => ({
+		name: kebabCase(m.name),
+		operations: m.operations.filter((op) => op.name !== null).map((op) => ({
+			name: op.name,
+			schema: applyGraphQLTypePrefixes(op.schema ?? "", pascalCaseDocumentType, stateTypeNames)
+		}))
+	}));
+	getOrCreateSourceFile(project, path$1.join(dirPath, "schema.ts")).sourceFile.replaceWithText(documentModelSubgraphSchemaTemplate({
+		pascalCaseDocumentType,
+		modules
+	}));
+	getOrCreateSourceFile(project, path$1.join(dirPath, "resolvers.ts")).sourceFile.replaceWithText(documentModelSubgraphResolversTemplate({
+		pascalCaseDocumentType,
+		camelCaseDocumentType,
+		phDocumentTypeName,
+		documentTypeVariableName,
+		documentModelDir,
+		modules
+	}));
+}
+//#endregion
+//#region src/file-builders/subgraphs.ts
+async function makeSubgraphsIndexFile({ projectDir }) {
+	const project = new Project({
+		tsConfigFilePath: path$1.join(projectDir, "tsconfig.json"),
+		skipAddingFilesFromTsConfig: true,
+		skipLoadingLibFiles: true,
+		manipulationSettings: {
+			useTrailingCommas: true,
+			indentationText: IndentationText.TwoSpaces
+		}
+	});
+	project.addSourceFilesAtPaths(`${projectDir}/subgraphs/**/*`);
+	const subgraphsSubdirs = project.getDirectory(path$1.join(projectDir, "subgraphs"))?.getDirectories() ?? [];
+	let subgraphsIndexSourceFile = project.getSourceFile(path$1.join(projectDir, "subgraphs/index.ts"));
+	if (!subgraphsIndexSourceFile) subgraphsIndexSourceFile = project.createSourceFile(path$1.join(projectDir, "subgraphs/index.js"), "");
+	for (const subgraphSubdir of subgraphsSubdirs) {
+		const subgraphIndexSourceFilePath = `${subgraphSubdir.getPath()}/index.ts`;
+		const subgraphIndexSourceFile = project.getSourceFile(subgraphIndexSourceFilePath);
+		if (!subgraphIndexSourceFile) continue;
+		const subgraphClassName = subgraphIndexSourceFile.getClasses().find((c) => c.getBaseClass()?.getText().includes("BaseSubgraph"))?.getName();
+		if (!subgraphClassName) continue;
+		if (subgraphsIndexSourceFile.getExportDeclarations().map((e) => e.getNamespaceExport()?.getText()).filter((e) => e !== void 0).join().includes(subgraphClassName)) continue;
+		subgraphsIndexSourceFile.addExportDeclaration({
+			namespaceExport: subgraphClassName,
+			moduleSpecifier: `./${subgraphSubdir.getBaseName()}/index.js`
+		});
+	}
+	await project.save();
+}
+//#endregion
+export { tsMorphGenerateProcessor as C, scalarsValidation as S, buildBoilerplatePackageJson as _, tsMorphGenerateDocumentEditor as a, generateTypesAndZodSchemasFromGraphql as b, makeModulesFile as c, makeLegacyIndexFile as d, makeEditorModuleFile as f, writeCliDocsMarkdownFile as g, makeCliDocsFromHelp as h, tsMorphGenerateDocumentModel as i, makeUpgradeManifestsExport as l, getCommandsHelpInfo as m, tsMorphGenerateSubgraph as n, makeDocumentModelModulesFile as o, getCommandHelpInfo as p, tsMorphGenerateDriveEditor as r, makeEditorsModulesFile as s, makeSubgraphsIndexFile as t, makeUpgradeManifestsFile as u, generateDocumentModelZodSchemas as v, scalars as x, generateSchemas as y };
+
+//# sourceMappingURL=file-builders-BRJcuumC.mjs.map