@elek-io/core 0.15.0 → 0.15.2

package/dist/cli/index.cli.js

@@ -0,0 +1,4004 @@
+#! /usr/bin/env node
+import { Command } from "@commander-js/extra-typings";
+import Path from "path";
+import Fs from "fs-extra";
+import { build } from "tsdown";
+import CodeBlockWriter from "code-block-writer";
+import assert from "assert";
+import chokidar from "chokidar";
+import { serve } from "@hono/node-server";
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { requestId } from "hono/request-id";
+import { createMiddleware } from "hono/factory";
+import { cors } from "hono/cors";
+import { trimTrailingSlash } from "hono/trailing-slash";
+import { z as z$1 } from "zod";
+import { Scalar } from "@scalar/hono-api-reference";
+import Os from "os";
+import { execFile } from "child_process";
+import mime from "mime";
+import slugify from "@sindresorhus/slugify";
+import { v4 } from "uuid";
+import { GitProcess } from "dugite";
+import PQueue from "p-queue";
+import { createLogger, format, transports } from "winston";
+import DailyRotateFile from "winston-daily-rotate-file";
+import Semver from "semver";
+
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (all) => {
+	let target = {};
+	for (var name$1 in all) __defProp(target, name$1, {
+		get: all[name$1],
+		enumerable: true
+	});
+	return target;
+};
+
+//#endregion
+//#region package.json
+var package_default = {
+	name: "@elek-io/core",
+	version: "0.15.2",
+	description: "Handles core functionality of elek.io Projects like file IO and version control.",
+	homepage: "https://elek.io",
+	repository: "https://github.com/elek-io/core",
+	bugs: { "url": "https://github.com/elek-io/core/issues" },
+	type: "module",
+	bin: { "elek": "./dist/cli/index.cli.js" },
+	files: ["dist/node", "dist/browser"],
+	exports: { ".": {
+		"node": { "import": {
+			"types": "./dist/node/index.node.d.ts",
+			"default": "./dist/node/index.node.js"
+		} },
+		"import": {
+			"types": "./dist/browser/index.browser.d.ts",
+			"default": "./dist/browser/index.browser.js"
+		}
+	} },
+	pnpm: { "overrides": {} },
+	scripts: {
+		"lint": "eslint",
+		"check-types": "tsc --noEmit",
+		"check-format": "prettier --check . || exit 0",
+		"format": "prettier --write .",
+		"dev": "vitest",
+		"test": "vitest run",
+		"coverage": "vitest run --coverage",
+		"build": "tsdown",
+		"release": "changeset publish"
+	},
+	dependencies: {
+		"@commander-js/extra-typings": "14.0.0",
+		"@hono/node-server": "1.19.5",
+		"@hono/zod-openapi": "1.1.4",
+		"@scalar/hono-api-reference": "0.9.22",
+		"@sindresorhus/slugify": "3.0.0",
+		"chokidar": "4.0.3",
+		"code-block-writer": "13.0.3",
+		"commander": "14.0.2",
+		"fs-extra": "11.3.2",
+		"hono": "4.10.4",
+		"mime": "4.1.0",
+		"p-queue": "9.0.0",
+		"semver": "7.7.3",
+		"tsdown": "0.15.12",
+		"uuid": "13.0.0",
+		"winston": "3.18.3",
+		"winston-daily-rotate-file": "5.0.0",
+		"zod": "4.1.12"
+	},
+	devDependencies: {
+		"@changesets/cli": "2.29.7",
+		"@eslint/js": "9.38.0",
+		"@faker-js/faker": "10.1.0",
+		"@tsconfig/node22": "22.0.2",
+		"@tsconfig/strictest": "2.0.7",
+		"@types/fs-extra": "11.0.4",
+		"@types/node": "22.18.13",
+		"@types/semver": "7.7.1",
+		"@vitest/coverage-v8": "4.0.5",
+		"eslint": "9.38.0",
+		"eslint-config-prettier": "10.1.8",
+		"globals": "16.4.0",
+		"jiti": "2.6.1",
+		"prettier": "3.6.2",
+		"typescript": "5.9.3",
+		"typescript-eslint": "8.46.2",
+		"vitest": "4.0.5"
+	},
+	peerDependencies: { "dugite": "2.7.1" }
+};
+
+//#endregion
+//#region src/cli/exportAction.ts
+async function exportProjects({ outDir, projects, options }) {
+	const projectsToExport = [];
+	const resolvedOutDir = Path.resolve(outDir);
+	await Fs.ensureDir(resolvedOutDir);
+	let content = {};
+	if (projects === "all") projectsToExport.push(...(await core.projects.list({ limit: 0 })).list);
+	else for (const projectId of projects) projectsToExport.push(await core.projects.read({ id: projectId }));
+	for (const project of projectsToExport) {
+		const assets = (await core.assets.list({
+			projectId: project.id,
+			limit: 0
+		})).list;
+		let assetContent = {};
+		for (const asset of assets) assetContent = {
+			...assetContent,
+			[asset.id]: { ...asset }
+		};
+		let collectionContent = {};
+		const collections = (await core.collections.list({
+			projectId: project.id,
+			limit: 0
+		})).list;
+		for (const collection of collections) {
+			let entryContent = {};
+			const entries = (await core.entries.list({
+				projectId: project.id,
+				collectionId: collection.id,
+				limit: 0
+			})).list;
+			for (const entry of entries) entryContent = {
+				...entryContent,
+				[entry.id]: { ...entry }
+			};
+			collectionContent = {
+				...collectionContent,
+				[collection.id]: {
+					...collection,
+					entries: entryContent
+				}
+			};
+		}
+		content = {
+			...content,
+			[project.id]: {
+				...project,
+				assets: assetContent,
+				collections: collectionContent
+			}
+		};
+	}
+	if (options.separate === true) for (const project of projectsToExport) await Fs.writeFile(Path.join(resolvedOutDir, `project-${project.id}.json`), JSON.stringify(content[project.id], null, 2));
+	else await Fs.writeFile(Path.join(resolvedOutDir, "projects.json"), JSON.stringify(content, null, 2));
+}
+const exportAction = async ({ outDir, projects, options }) => {
+	await exportProjects({
+		outDir,
+		projects,
+		options
+	});
+	if (options.watch === true) {
+		core.logger.info({
+			source: "core",
+			message: "Watching for changes to export Projects"
+		});
+		watchProjects().on("all", (event, path) => {
+			core.logger.info({
+				source: "core",
+				message: `Re-Exporting Projects due to ${event} on "${path}"`
+			});
+			exportProjects({
+				outDir,
+				projects,
+				options
+			});
+		});
+	}
+};
+
+//#endregion
+//#region src/cli/startApiAction.ts
+const startApiAction = ({ port }) => {
+	return core.api.start(port);
+};
+
+//#endregion
+//#region src/cli/generateApiClientAction.ts
+/**
+* API Client generator
+*
+* Generates an API client with full type safety in given folder
+* based on the locally available Projects, Collections and Entries.
+* Uses a generated schema based on the field definitions
+* of Collections to provide correct types for available Entries.
+*
+* @example
+* Usage: Import the generated client and use it to access the local content API
+*
+* ```ts
+* import { apiClient } from './.elek.io/client.js';
+*
+* const client = await apiClient({
+*   baseUrl: 'http://localhost:31310',
+*   apiKey: '<token>'
+* }).content.v1;
+*
+* const entries = await client
+*   .projects['d9920ad7-07b8-41c4-84f7-5d6babf0f800']
+*   .collections['7fc70100-82b3-41f8-b4de-705a84b0a95d']
+*   .entries.list({
+*     limit: 10,
+*   })
+*
+* console.log(entries);
+* ```
+*/
+async function generateApiClient(outFile) {
+	const writer = new CodeBlockWriter({
+		newLine: "\n",
+		indentNumberOfSpaces: 2,
+		useTabs: false,
+		useSingleQuote: true
+	});
+	writer.writeLine(`import { paginatedListOf, getEntrySchemaFromFieldDefinitions } from '@elek-io/core';`);
+	writer.writeLine(`import { z } from 'zod';`);
+	writer.blankLine();
+	writer.writeLine(`const listSchema = z.object({ limit: z.number().optional(), offset: z.number().optional() }).optional();`);
+	writer.writeLine(`type ListProps = z.infer<typeof listSchema>;`);
+	writer.blankLine();
+	writer.writeLine(`const apiClientSchema = z.object({ baseUrl: z.url(), apiKey: z.string() });`);
+	writer.writeLine(`type ApiClientProps = z.infer<typeof apiClientSchema>;`);
+	writer.blankLine();
+	writer.writeLine(`/**`);
+	writer.writeLine(` * elek.io Client`);
+	writer.writeLine(` * `);
+	writer.writeLine(` * Used to access elek.io APIs.`);
+	writer.writeLine(` */`);
+	writer.writeLine(`export function apiClient({ baseUrl, apiKey }: ApiClientProps) {`);
+	writer.indent(1).write(`apiClientSchema.parse({ baseUrl, apiKey });`).newLine();
+	writer.blankLine();
+	writer.indent(1).write(`return {`).newLine();
+	writer.indent(2).write(`content: {`).newLine();
+	writer.indent(3).write(`v1: {`).newLine();
+	writer.indent(4).write(`projects: {`).newLine();
+	await writeProjectsObject(writer);
+	writer.indent(4).write(`}`).newLine();
+	writer.indent(3).write(`}`).newLine();
+	writer.indent(2).write(`}`).newLine();
+	writer.indent(1).write(`}`).newLine();
+	writer.writeLine(`}`);
+	await Fs.writeFile(outFile, writer.toString());
+	core.logger.info({
+		source: "core",
+		message: `Generated API Client in "${outFile}"`
+	});
+}
+async function writeProjectsObject(writer) {
+	const projects = await core.projects.list({
+		limit: 0,
+		offset: 0
+	});
+	for (let index = 0; index < projects.list.length; index++) {
+		const project = projects.list[index];
+		assert(project, "Project not found by index");
+		writer.indent(1).quote(project.id).write(`: {`).newLine();
+		writer.indent(2).write(`collections: {`).newLine();
+		await writeCollectionsObject(writer, project);
+		writer.indent(2).write(`},`).newLine();
+		writer.indent(1).write(`},`).newLine();
+	}
+}
+async function writeCollectionsObject(writer, project) {
+	const collections = await core.collections.list({
+		projectId: project.id,
+		limit: 0,
+		offset: 0
+	});
+	for (let index = 0; index < collections.list.length; index++) {
+		const collection = collections.list[index];
+		assert(collection, "Collection not found by index");
+		writer.indent(3).quote(collection.id).write(`: {`).newLine();
+		writer.indent(4).write(`entries: {`).newLine();
+		writeEntriesObject(writer, project, collection);
+		writer.indent(4).write(`},`).newLine();
+		writer.indent(3).write(`},`).newLine();
+	}
+}
+function writeEntriesObject(writer, project, collection) {
+	writer.indent(5).write(`list: async (props?: ListProps) => {`).newLine();
+	writer.indent(6).write(`listSchema.parse(props);`).newLine();
+	writer.indent(6).write(`const entrySchema = paginatedListOf(getEntrySchemaFromFieldDefinitions(`).newLine();
+	writer.setIndentationLevel(6);
+	writer.indent(() => {
+		writer.write(JSON.stringify(collection.fieldDefinitions, null, 2)).newLine();
+	});
+	writer.setIndentationLevel(0);
+	writer.indent(6).write(`));`).newLine();
+	writer.blankLine();
+	writeFetch(writer, `/content/v1/projects/${project.id}/collections/${collection.id}/entries`);
+	writer.blankLine();
+	writer.indent(6).write(`return entrySchema.parse(entries);`).newLine();
+	writer.indent(5).write(`},`).newLine();
+}
+function writeFetch(writer, to, method = "GET") {
+	writer.write("const response = await fetch(`${baseUrl}").write(to).write("`, ").block(() => {
+		writer.writeLine(`method: '${method}',`);
+		writer.write(`headers: `).block(() => {
+			writer.writeLine(`'Authorization': \`Bearer \${apiKey}\`,`);
+			writer.writeLine(`'Content-Type': 'application/json'`);
+		}).newLine();
+	}).write(`);`).newLine();
+	writer.writeLine(`const entries = await response.json();`);
+}
+async function generateApiClientAs({ outDir, language, format: format$1, target }) {
+	const resolvedOutDir = Path.resolve(outDir);
+	await Fs.ensureDir(resolvedOutDir);
+	const outFileTs = Path.join(resolvedOutDir, "client.ts");
+	await generateApiClient(outFileTs);
+	if (language === "js") {
+		await build({
+			config: false,
+			external: ["@elek-io/core", "zod"],
+			entry: outFileTs.split(Path.sep).join(Path.posix.sep),
+			outDir: resolvedOutDir,
+			format: format$1,
+			target,
+			sourcemap: true,
+			clean: false,
+			dts: true,
+			minify: true
+		});
+		await Fs.remove(outFileTs);
+	}
+}
+const generateApiClientAction = async ({ outDir, language, format: format$1, target, options }) => {
+	await generateApiClientAs({
+		outDir,
+		language,
+		format: format$1,
+		target,
+		options
+	});
+	if (options.watch === true) {
+		core.logger.info({
+			source: "core",
+			message: "Watching for changes to regenerate the API Client"
+		});
+		watchProjects().on("all", (event, path) => {
+			core.logger.info({
+				source: "core",
+				message: `Regenerating API Client due to ${event} on "${path}"`
+			});
+			generateApiClientAs({
+				outDir,
+				language,
+				format: format$1,
+				target,
+				options
+			});
+		});
+	}
+};
+
+//#endregion
+//#region src/api/middleware/requestResponseLogger.ts
+/**
+* Middleware that logs the details of each request and response
+*/
+const requestResponseLogger = createMiddleware(async (c, next) => {
+	const { method, url } = c.req;
+	const requestId$1 = c.get("requestId");
+	c.var.logService.info({
+		source: "core",
+		message: `Recieved API request "${method} ${url}" with requestId ${requestId$1}`
+	});
+	const start = Date.now();
+	await next();
+	const durationMs = Date.now() - start;
+	const statusCode = c.res.status.toString();
+	const resultLog = {
+		source: "core",
+		message: `Response for API request "${method} ${url}" with requestId ${requestId$1} and status code ${statusCode} in ${durationMs}ms`
+	};
+	if (statusCode.startsWith("2")) c.var.logService.info(resultLog);
+	else if (statusCode.startsWith("3")) c.var.logService.warn(resultLog);
+	else if (statusCode.startsWith("4") || statusCode.startsWith("5")) c.var.logService.error(resultLog);
+});
+
+//#endregion
+//#region src/api/lib/util.ts
+/**
+* Creates a new OpenAPIHono router with default settings
+*/
+function createRouter() {
+	return new OpenAPIHono({ defaultHook: (result, c) => {
+		if (!result.success) return c.json({
+			success: result.success,
+			error: {
+				name: result.error.name,
+				issues: result.error.issues
+			}
+		}, 422);
+		return result;
+	} });
+}
+/**
+* Creates a new OpenAPIHono instance, injects services into context and adds error handling
+*/
+function createApi(logService, projectService, collectionService, entryService, assetService) {
+	const api = createRouter();
+	api.use(requestId()).use(trimTrailingSlash()).use(cors({ origin: ["http://localhost"] })).use(createMiddleware((c, next) => {
+		c.set("logService", logService);
+		c.set("projectService", projectService);
+		c.set("collectionService", collectionService);
+		c.set("entryService", entryService);
+		c.set("assetService", assetService);
+		return next();
+	})).use(requestResponseLogger);
+	api.notFound((c) => {
+		return c.json({ message: `Not Found - ${c.req.path}` }, 404);
+	});
+	api.onError((err, c) => {
+		const currentStatus = "status" in err ? err.status : c.newResponse(null).status;
+		const statusCode = currentStatus !== 200 ? currentStatus : 500;
+		return c.json({
+			message: err.message,
+			stack: err.stack
+		}, statusCode);
+	});
+	return api;
+}
+
+//#endregion
+//#region src/schema/baseSchema.ts
+/**
+* All currently supported, BCP 47 compliant language tags
+*
+* The support depends on the tools and libraries we use.
+* We can't support a given language, if there is no support
+* for it from used third parties. Currently, to check if a langauge
+* tag can be added to this list, it needs to be supported by:
+* - DeepL translation API
+*
+* @see https://www.deepl.com/docs-api/other-functions/listing-supported-languages/
+*/
+const supportedLanguageSchema = z.enum([
+	"bg",
+	"cs",
+	"da",
+	"de",
+	"el",
+	"en",
+	"es",
+	"et",
+	"fi",
+	"fr",
+	"hu",
+	"it",
+	"ja",
+	"lt",
+	"lv",
+	"nl",
+	"pl",
+	"pt",
+	"ro",
+	"ru",
+	"sk",
+	"sl",
+	"sv",
+	"zh"
+]);
+const supportedIconSchema = z.enum([
+	"home",
+	"plus",
+	"foobar"
+]);
+const objectTypeSchema = z.enum([
+	"project",
+	"asset",
+	"collection",
+	"entry",
+	"value",
+	"sharedValue"
+]);
+const logLevelSchema = z.enum([
+	"error",
+	"warn",
+	"info",
+	"debug"
+]);
+const versionSchema = z.string();
+const uuidSchema = z.uuid("shared.invalidUuid");
+/**
+* A record that can be used to translate a string value into all supported languages
+*/
+const translatableStringSchema = z.partialRecord(supportedLanguageSchema, z.string().trim().min(1, "shared.translatableStringRequired"));
+/**
+* A record that can be used to translate a number value into all supported languages
+*/
+const translatableNumberSchema = z.partialRecord(supportedLanguageSchema, z.number({ error: (error) => error.input === void 0 ? "shared.translatableNumberRequired" : "shared.translatableNumberNotANumber" }));
+/**
+* A record that can be used to translate a boolean value into all supported languages
+*/
+const translatableBooleanSchema = z.partialRecord(supportedLanguageSchema, z.boolean({ error: (error) => error.input === void 0 ? "shared.translatableBooleanRequired" : "shared.translatableBooleanNotABoolean" }));
+function translatableArrayOf(schema) {
+	return z.partialRecord(supportedLanguageSchema, z.array(schema));
+}
+
+//#endregion
+//#region src/schema/fileSchema.ts
+/**
+* A basic file structure every elek.io file on disk has to follow
+*/
+const baseFileSchema = z.object({
+	objectType: objectTypeSchema.readonly(),
+	id: uuidSchema.readonly(),
+	created: z.string().datetime().readonly(),
+	updated: z.string().datetime().nullable()
+});
+const fileReferenceSchema = z.object({
+	id: uuidSchema,
+	extension: z.string().optional()
+});
+
+//#endregion
+//#region src/schema/gitSchema.ts
+/**
+* Signature git uses to identify users
+*/
+const gitSignatureSchema = z.object({
+	name: z.string(),
+	email: z.string().email()
+});
+const gitMessageSchema = z.object({
+	method: z.enum([
+		"create",
+		"update",
+		"delete",
+		"upgrade"
+	]),
+	reference: z.object({
+		objectType: objectTypeSchema,
+		id: uuidSchema,
+		collectionId: uuidSchema.optional()
+	})
+});
+const gitTagSchema = z.object({
+	id: uuidSchema,
+	message: z.string(),
+	author: gitSignatureSchema,
+	datetime: z.string().datetime()
+});
+const gitCommitSchema = z.object({
+	hash: z.string(),
+	message: gitMessageSchema,
+	author: gitSignatureSchema,
+	datetime: z.string().datetime(),
+	tag: gitTagSchema.nullable()
+});
+const gitInitOptionsSchema = z.object({ initialBranch: z.string() });
+const gitCloneOptionsSchema = z.object({
+	depth: z.number(),
+	singleBranch: z.boolean(),
+	branch: z.string(),
+	bare: z.boolean()
+});
+const gitMergeOptionsSchema = z.object({ squash: z.boolean() });
+const gitSwitchOptionsSchema = z.object({ isNew: z.boolean().optional() });
+const gitLogOptionsSchema = z.object({
+	limit: z.number().optional(),
+	between: z.object({
+		from: z.string(),
+		to: z.string().optional()
+	}),
+	filePath: z.string().optional()
+});
+const createGitTagSchema = gitTagSchema.pick({ message: true }).extend({
+	path: z.string(),
+	hash: z.string().optional()
+});
+const readGitTagSchema = z.object({
+	path: z.string(),
+	id: uuidSchema.readonly()
+});
+const deleteGitTagSchema = readGitTagSchema.extend({});
+const countGitTagsSchema = z.object({ path: z.string() });
+
+//#endregion
+//#region src/schema/assetSchema.ts
+const assetFileSchema = baseFileSchema.extend({
+	objectType: z.literal(objectTypeSchema.enum.asset).readonly(),
+	name: z.string(),
+	description: z.string(),
+	extension: z.string().readonly(),
+	mimeType: z.string().readonly(),
+	size: z.number().readonly()
+});
+const assetSchema = assetFileSchema.extend({
+	absolutePath: z.string().readonly(),
+	history: z.array(gitCommitSchema)
+}).openapi("Asset");
+const assetExportSchema = assetSchema.extend({});
+const createAssetSchema = assetFileSchema.pick({
+	name: true,
+	description: true
+}).extend({
+	projectId: uuidSchema.readonly(),
+	filePath: z.string().readonly()
+});
+const readAssetSchema = assetFileSchema.pick({ id: true }).extend({
+	projectId: uuidSchema.readonly(),
+	commitHash: z.string().optional().readonly()
+});
+const saveAssetSchema = assetFileSchema.pick({ id: true }).extend({
+	projectId: uuidSchema.readonly(),
+	filePath: z.string().readonly(),
+	commitHash: z.string().optional().readonly()
+});
+const updateAssetSchema = assetFileSchema.pick({
+	id: true,
+	name: true,
+	description: true
+}).extend({
+	projectId: uuidSchema.readonly(),
+	newFilePath: z.string().readonly().optional()
+});
+const deleteAssetSchema = assetFileSchema.pick({
+	id: true,
+	extension: true
+}).extend({ projectId: uuidSchema.readonly() });
+const countAssetsSchema = z.object({ projectId: uuidSchema.readonly() });
+
+//#endregion
+//#region src/schema/valueSchema.ts
+const ValueTypeSchema = z.enum([
+	"string",
+	"number",
+	"boolean",
+	"reference"
+]);
+const valueContentReferenceBase = z.object({ id: uuidSchema });
+const valueContentReferenceToAssetSchema = valueContentReferenceBase.extend({ objectType: z.literal(objectTypeSchema.enum.asset) });
+const valueContentReferenceToCollectionSchema = valueContentReferenceBase.extend({ objectType: z.literal(objectTypeSchema.enum.collection) });
+const valueContentReferenceToEntrySchema = valueContentReferenceBase.extend({ objectType: z.literal(objectTypeSchema.enum.entry) });
+const valueContentReferenceSchema = z.union([
+	valueContentReferenceToAssetSchema,
+	valueContentReferenceToCollectionSchema,
+	valueContentReferenceToEntrySchema
+]);
+const directValueBaseSchema = z.object({
+	objectType: z.literal(objectTypeSchema.enum.value).readonly(),
+	fieldDefinitionId: uuidSchema.readonly()
+});
+const directStringValueSchema = directValueBaseSchema.extend({
+	valueType: z.literal(ValueTypeSchema.enum.string).readonly(),
+	content: translatableStringSchema
+});
+const directNumberValueSchema = directValueBaseSchema.extend({
+	valueType: z.literal(ValueTypeSchema.enum.number).readonly(),
+	content: translatableNumberSchema
+});
+const directBooleanValueSchema = directValueBaseSchema.extend({
+	valueType: z.literal(ValueTypeSchema.enum.boolean).readonly(),
+	content: translatableBooleanSchema
+});
+const directValueSchema = z.union([
+	directStringValueSchema,
+	directNumberValueSchema,
+	directBooleanValueSchema
+]);
+const referencedValueSchema = z.object({
+	objectType: z.literal(objectTypeSchema.enum.value).readonly(),
+	fieldDefinitionId: uuidSchema.readonly(),
+	valueType: z.literal(ValueTypeSchema.enum.reference).readonly(),
+	content: translatableArrayOf(valueContentReferenceSchema)
+});
+const valueSchema = z.union([directValueSchema, referencedValueSchema]);
+/**
+* ---
+*/
+/**
+* @todo maybe we need to validate Values and shared Values
+*/
+
+//#endregion
+//#region src/schema/entrySchema.ts
+const entryFileSchema = baseFileSchema.extend({
+	objectType: z.literal(objectTypeSchema.enum.entry).readonly(),
+	values: z.array(valueSchema)
+});
+const entrySchema = entryFileSchema.extend({ history: z.array(gitCommitSchema) }).openapi("Entry");
+const entryExportSchema = entrySchema.extend({});
+const createEntrySchema = entryFileSchema.omit({
+	id: true,
+	objectType: true,
+	created: true,
+	updated: true
+}).extend({
+	projectId: uuidSchema.readonly(),
+	collectionId: uuidSchema.readonly(),
+	values: z.array(valueSchema)
+});
+const readEntrySchema = z.object({
+	id: uuidSchema.readonly(),
+	projectId: uuidSchema.readonly(),
+	collectionId: uuidSchema.readonly(),
+	commitHash: z.string().optional().readonly()
+});
+const updateEntrySchema = entryFileSchema.omit({
+	objectType: true,
+	created: true,
+	updated: true
+}).extend({
+	projectId: uuidSchema.readonly(),
+	collectionId: uuidSchema.readonly()
+});
+const deleteEntrySchema = readEntrySchema.extend({});
+const countEntriesSchema = z.object({
+	projectId: uuidSchema.readonly(),
+	collectionId: uuidSchema.readonly()
+});
+
+//#endregion
+//#region src/schema/fieldSchema.ts
+const FieldTypeSchema = z.enum([
+	"text",
+	"textarea",
+	"email",
+	"url",
+	"ipv4",
+	"date",
+	"time",
+	"datetime",
+	"telephone",
+	"number",
+	"range",
+	"toggle",
+	"asset",
+	"entry"
+]);
+const FieldWidthSchema = z.enum([
+	"12",
+	"6",
+	"4",
+	"3"
+]);
+const FieldDefinitionBaseSchema = z.object({
+	id: uuidSchema.readonly(),
+	label: translatableStringSchema,
+	description: translatableStringSchema.nullable(),
+	isRequired: z.boolean(),
+	isDisabled: z.boolean(),
+	isUnique: z.boolean(),
+	inputWidth: FieldWidthSchema
+});
+/**
+* String based Field definitions
+*/
+const StringFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend({
+	valueType: z.literal(ValueTypeSchema.enum.string),
+	defaultValue: z.string().nullable()
+});
+const textFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
+	fieldType: z.literal(FieldTypeSchema.enum.text),
+	min: z.number().nullable(),
+	max: z.number().nullable()
+});
+const textareaFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
+	fieldType: z.literal(FieldTypeSchema.enum.textarea),
+	min: z.number().nullable(),
+	max: z.number().nullable()
+});
+const emailFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
+	fieldType: z.literal(FieldTypeSchema.enum.email),
+	defaultValue: z.email().nullable()
+});
+const urlFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
+	fieldType: z.literal(FieldTypeSchema.enum.url),
+	defaultValue: z.url().nullable()
+});
+const ipv4FieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
+	fieldType: z.literal(FieldTypeSchema.enum.ipv4),
+	defaultValue: z.ipv4().nullable()
+});
+const dateFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
+	fieldType: z.literal(FieldTypeSchema.enum.date),
+	defaultValue: z.iso.date().nullable()
+});
+const timeFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
+	fieldType: z.literal(FieldTypeSchema.enum.time),
+	defaultValue: z.iso.time().nullable()
+});
+const datetimeFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
+	fieldType: z.literal(FieldTypeSchema.enum.datetime),
+	defaultValue: z.iso.datetime().nullable()
+});
+const telephoneFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
+	fieldType: z.literal(FieldTypeSchema.enum.telephone),
+	defaultValue: z.e164().nullable()
+});
+const stringFieldDefinitionSchema = z.union([
+	textFieldDefinitionSchema,
+	textareaFieldDefinitionSchema,
+	emailFieldDefinitionSchema,
+	urlFieldDefinitionSchema,
+	ipv4FieldDefinitionSchema,
+	dateFieldDefinitionSchema,
+	timeFieldDefinitionSchema,
+	datetimeFieldDefinitionSchema,
+	telephoneFieldDefinitionSchema
+]);
+/**
+* Number based Field definitions
+*/
+const NumberFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend({
+	valueType: z.literal(ValueTypeSchema.enum.number),
+	min: z.number().nullable(),
+	max: z.number().nullable(),
+	isUnique: z.literal(false),
+	defaultValue: z.number().nullable()
+});
+const numberFieldDefinitionSchema = NumberFieldDefinitionBaseSchema.extend({ fieldType: z.literal(FieldTypeSchema.enum.number) });
+const rangeFieldDefinitionSchema = NumberFieldDefinitionBaseSchema.extend({
+	fieldType: z.literal(FieldTypeSchema.enum.range),
+	isRequired: z.literal(true),
+	min: z.number(),
+	max: z.number(),
+	defaultValue: z.number()
+});
+/**
+* Boolean based Field definitions
+*/
+const BooleanFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend({
+	valueType: z.literal(ValueTypeSchema.enum.boolean),
+	isRequired: z.literal(true),
+	defaultValue: z.boolean(),
+	isUnique: z.literal(false)
+});
+const toggleFieldDefinitionSchema = BooleanFieldDefinitionBaseSchema.extend({ fieldType: z.literal(FieldTypeSchema.enum.toggle) });
+/**
+* Reference based Field definitions
+*/
+const ReferenceFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend({ valueType: z.literal(ValueTypeSchema.enum.reference) });
+const assetFieldDefinitionSchema = ReferenceFieldDefinitionBaseSchema.extend({
+	fieldType: z.literal(FieldTypeSchema.enum.asset),
+	min: z.number().nullable(),
+	max: z.number().nullable()
+});
+const entryFieldDefinitionSchema = ReferenceFieldDefinitionBaseSchema.extend({
+	fieldType: z.literal(FieldTypeSchema.enum.entry),
+	ofCollections: z.array(uuidSchema),
+	min: z.number().nullable(),
+	max: z.number().nullable()
+});
+const fieldDefinitionSchema = z.union([
+	stringFieldDefinitionSchema,
+	numberFieldDefinitionSchema,
+	rangeFieldDefinitionSchema,
+	toggleFieldDefinitionSchema,
+	assetFieldDefinitionSchema,
+	entryFieldDefinitionSchema
+]);
+
+//#endregion
+//#region src/schema/collectionSchema.ts
+const collectionFileSchema = baseFileSchema.extend({
+	objectType: z.literal(objectTypeSchema.enum.collection).readonly(),
+	name: z.object({
+		singular: translatableStringSchema,
+		plural: translatableStringSchema
+	}),
+	slug: z.object({
+		singular: z.string(),
+		plural: z.string()
+	}),
+	description: translatableStringSchema,
+	icon: supportedIconSchema,
+	fieldDefinitions: z.array(fieldDefinitionSchema)
+});
+const collectionSchema = collectionFileSchema.extend({ history: z.array(gitCommitSchema) }).openapi("Collection");
+const collectionExportSchema = collectionSchema.extend({ entries: z.array(entryExportSchema) });
+const createCollectionSchema = collectionFileSchema.omit({
+	id: true,
+	objectType: true,
+	created: true,
+	updated: true
+}).extend({ projectId: uuidSchema.readonly() });
+const readCollectionSchema = z.object({
+	id: uuidSchema.readonly(),
+	projectId: uuidSchema.readonly(),
+	commitHash: z.string().optional().readonly()
+});
+const updateCollectionSchema = collectionFileSchema.pick({
+	id: true,
+	name: true,
+	slug: true,
+	description: true,
+	icon: true,
+	fieldDefinitions: true
+}).extend({ projectId: uuidSchema.readonly() });
+const deleteCollectionSchema = readCollectionSchema.extend({});
+const countCollectionsSchema = z.object({ projectId: uuidSchema.readonly() });
+
+//#endregion
+//#region src/schema/coreSchema.ts
+/**
+* Options that can be passed to elek.io core
+*/
+const elekIoCoreOptionsSchema = z.object({
+	log: z.object({ level: logLevelSchema }),
+	file: z.object({ cache: z.boolean() })
+});
+const constructorElekIoCoreSchema = elekIoCoreOptionsSchema.partial({
+	log: true,
+	file: true
+}).optional();
+
+//#endregion
+//#region src/schema/projectSchema.ts
+const projectStatusSchema = z.enum([
+	"foo",
+	"bar",
+	"todo"
+]);
+const projectSettingsSchema = z.object({ language: z.object({
+	default: supportedLanguageSchema,
+	supported: z.array(supportedLanguageSchema)
+}) });
+const projectFolderSchema = z.enum([
+	"assets",
+	"collections",
+	"shared-values",
+	"lfs"
+]);
+const projectBranchSchema = z.enum(["production", "work"]);
+const projectFileSchema = baseFileSchema.extend({
+	objectType: z.literal(objectTypeSchema.enum.project).readonly(),
+	coreVersion: versionSchema,
+	name: z.string().trim().min(1, "shared.projectNameRequired"),
+	description: z.string().trim().min(1, "shared.projectDescriptionRequired"),
+	version: versionSchema,
+	status: projectStatusSchema,
+	settings: projectSettingsSchema
+});
+const projectSchema = projectFileSchema.extend({
+	remoteOriginUrl: z.string().nullable().openapi({ description: "URL of the remote Git repository" }),
+	history: z.array(gitCommitSchema).openapi({ description: "Commit history of this Project" }),
+	fullHistory: z.array(gitCommitSchema).openapi({ description: "Full commit history of this Project including all Assets, Collections, Entries and other files" })
+}).openapi("Project");
+const outdatedProjectSchema = projectFileSchema.pick({
+	id: true,
+	name: true,
+	coreVersion: true
+});
+const projectExportSchema = projectSchema.extend({
+	assets: z.array(assetExportSchema),
+	collections: z.array(collectionExportSchema)
+});
+const createProjectSchema = projectSchema.pick({
+	name: true,
+	description: true,
+	settings: true
+}).partial({
+	description: true,
+	settings: true
+});
+const readProjectSchema = z.object({
+	id: uuidSchema.readonly(),
+	commitHash: z.string().optional().readonly()
+});
+const updateProjectSchema = projectSchema.pick({
+	id: true,
+	name: true,
+	description: true,
+	settings: true
+}).partial({
+	name: true,
+	description: true,
+	settings: true
+});
+const upgradeProjectSchema = z.object({
+	id: uuidSchema.readonly(),
+	force: z.boolean().optional()
+});
+const deleteProjectSchema = readProjectSchema.extend({ force: z.boolean().optional() });
+const projectUpgradeSchema = z.object({
+	to: versionSchema.readonly(),
+	run: z.function({
+		input: [projectFileSchema],
+		output: z.promise(z.void())
+	})
+});
+const cloneProjectSchema = z.object({ url: z.string() });
+const listBranchesProjectSchema = z.object({ id: uuidSchema.readonly() });
+const currentBranchProjectSchema = z.object({ id: uuidSchema.readonly() });
+const switchBranchProjectSchema = z.object({
+	id: uuidSchema.readonly(),
+	branch: z.string(),
+	options: gitSwitchOptionsSchema.optional()
+});
+const getRemoteOriginUrlProjectSchema = z.object({ id: uuidSchema.readonly() });
+const setRemoteOriginUrlProjectSchema = z.object({
+	id: uuidSchema.readonly(),
+	url: z.string()
+});
+const getChangesProjectSchema = z.object({ id: uuidSchema.readonly() });
+const synchronizeProjectSchema = z.object({ id: uuidSchema.readonly() });
+const searchProjectSchema = z.object({
+	id: uuidSchema.readonly(),
+	query: z.string(),
+	language: supportedLanguageSchema,
+	type: z.array(objectTypeSchema).optional()
+});
+
+//#endregion
+//#region src/schema/schemaFromFieldDefinition.ts
+/**
+* Boolean Values are always either true or false, so we don't need the Field definition here
+*/
+function getBooleanValueContentSchemaFromFieldDefinition() {
+	return z.boolean();
+}
+/**
+* Number Values can have min and max values and can be required or not
+*/
+function getNumberValueContentSchemaFromFieldDefinition(fieldDefinition) {
+	let schema = z.number();
+	if (fieldDefinition.min) schema = schema.min(fieldDefinition.min);
+	if (fieldDefinition.max) schema = schema.max(fieldDefinition.max);
+	if (fieldDefinition.isRequired === false) return schema.nullable();
+	return schema;
+}
+/**
+* String Values can have different formats (email, url, ipv4, date, time, ...)
+* and can have min and max length and can be required or not
+*/
+function getStringValueContentSchemaFromFieldDefinition(fieldDefinition) {
+	let schema = null;
+	switch (fieldDefinition.fieldType) {
+		case FieldTypeSchema.enum.email:
+			schema = z.email();
+			break;
+		case FieldTypeSchema.enum.url:
+			schema = z.url();
+			break;
+		case FieldTypeSchema.enum.ipv4:
+			schema = z.ipv4();
+			break;
+		case FieldTypeSchema.enum.date:
+			schema = z.iso.date();
+			break;
+		case FieldTypeSchema.enum.time:
+			schema = z.iso.time();
+			break;
+		case FieldTypeSchema.enum.datetime:
+			schema = z.iso.datetime();
+			break;
+		case FieldTypeSchema.enum.telephone:
+			schema = z.e164();
+			break;
+		case FieldTypeSchema.enum.text:
+		case FieldTypeSchema.enum.textarea:
+			schema = z.string().trim();
+			break;
+	}
+	if ("min" in fieldDefinition && fieldDefinition.min) schema = schema.min(fieldDefinition.min);
+	if ("max" in fieldDefinition && fieldDefinition.max) schema = schema.max(fieldDefinition.max);
+	if (fieldDefinition.isRequired === false) return schema.nullable();
+	return schema.min(1, "shared.stringValueRequired");
+}
+/**
+* Reference Values can reference either Assets or Entries (or Shared Values in the future)
+* and can have min and max number of references and can be required or not
+*/
+function getReferenceValueContentSchemaFromFieldDefinition(fieldDefinition) {
+	let schema;
+	switch (fieldDefinition.fieldType) {
+		case FieldTypeSchema.enum.asset:
+			schema = z.array(valueContentReferenceToAssetSchema);
+			break;
+		case FieldTypeSchema.enum.entry:
+			schema = z.array(valueContentReferenceToEntrySchema);
+			break;
+	}
+	if (fieldDefinition.isRequired) schema = schema.min(1, "shared.referenceRequired");
+	if (fieldDefinition.min) schema = schema.min(fieldDefinition.min);
+	if (fieldDefinition.max) schema = schema.max(fieldDefinition.max);
+	return schema;
+}
+function getTranslatableStringValueContentSchemaFromFieldDefinition(fieldDefinition) {
+	return z.partialRecord(supportedLanguageSchema, getStringValueContentSchemaFromFieldDefinition(fieldDefinition));
+}
+function getTranslatableNumberValueContentSchemaFromFieldDefinition(fieldDefinition) {
+	return z.partialRecord(supportedLanguageSchema, getNumberValueContentSchemaFromFieldDefinition(fieldDefinition));
+}
+function getTranslatableBooleanValueContentSchemaFromFieldDefinition() {
+	return z.partialRecord(supportedLanguageSchema, getBooleanValueContentSchemaFromFieldDefinition());
+}
+function getTranslatableReferenceValueContentSchemaFromFieldDefinition(fieldDefinition) {
+	return z.partialRecord(supportedLanguageSchema, getReferenceValueContentSchemaFromFieldDefinition(fieldDefinition));
+}
+/**
+* Generates a zod schema to check a Value based on given Field definition
+*/
+function getValueSchemaFromFieldDefinition(fieldDefinition) {
+	switch (fieldDefinition.valueType) {
+		case ValueTypeSchema.enum.boolean: return directBooleanValueSchema.extend({ content: getTranslatableBooleanValueContentSchemaFromFieldDefinition() });
+		case ValueTypeSchema.enum.number: return directNumberValueSchema.extend({ content: getTranslatableNumberValueContentSchemaFromFieldDefinition(fieldDefinition) });
+		case ValueTypeSchema.enum.string: return directStringValueSchema.extend({ content: getTranslatableStringValueContentSchemaFromFieldDefinition(fieldDefinition) });
+		case ValueTypeSchema.enum.reference: return referencedValueSchema.extend({ content: getTranslatableReferenceValueContentSchemaFromFieldDefinition(fieldDefinition) });
+		default: throw new Error(`Error generating schema for unsupported ValueType "${fieldDefinition.valueType}"`);
+	}
+}
+/**
+* Generates a schema for creating a new Entry based on the given Field definitions and Values
+*/
+function getCreateEntrySchemaFromFieldDefinitions(fieldDefinitions) {
+	const valueSchemas = fieldDefinitions.map((fieldDefinition) => {
+		return getValueSchemaFromFieldDefinition(fieldDefinition);
+	});
+	return z.object({
+		...createEntrySchema.shape,
+		values: z.tuple(valueSchemas)
+	});
+}
+/**
+* Generates a schema for updating an existing Entry based on the given Field definitions and Values
+*/
+function getUpdateEntrySchemaFromFieldDefinitions(fieldDefinitions) {
+	const valueSchemas = fieldDefinitions.map((fieldDefinition) => {
+		return getValueSchemaFromFieldDefinition(fieldDefinition);
+	});
+	return z.object({
+		...updateEntrySchema.shape,
+		values: z.tuple(valueSchemas)
+	});
+}
+
+//#endregion
+//#region src/schema/serviceSchema.ts
+const serviceTypeSchema = z.enum([
+	"Git",
+	"GitTag",
+	"User",
+	"Project",
+	"Asset",
+	"JsonFile",
+	"Search",
+	"Collection",
+	"Entry",
+	"Value"
+]);
+function paginatedListOf(schema) {
+	return z.object({
+		total: z.number(),
+		limit: z.number(),
+		offset: z.number(),
+		list: z.array(schema)
+	});
+}
+const listSchema = z.object({
+	projectId: uuidSchema,
+	limit: z.number().optional(),
+	offset: z.number().optional()
+});
+const listCollectionsSchema = listSchema;
+const listEntriesSchema = listSchema.extend({ collectionId: uuidSchema });
+const listAssetsSchema = listSchema;
+const listProjectsSchema = listSchema.omit({ projectId: true });
+const listGitTagsSchema = z.object({ path: z.string() });
+
+//#endregion
+//#region src/schema/userSchema.ts
+const UserTypeSchema = z.enum(["local", "cloud"]);
+const baseUserSchema = gitSignatureSchema.extend({
+	userType: UserTypeSchema,
+	language: supportedLanguageSchema,
+	localApi: z.object({
+		isEnabled: z.boolean(),
+		port: z.number()
+	})
+});
+const localUserSchema = baseUserSchema.extend({ userType: z.literal(UserTypeSchema.enum.local) });
+const cloudUserSchema = baseUserSchema.extend({
+	userType: z.literal(UserTypeSchema.enum.cloud),
+	id: uuidSchema
+});
+const userFileSchema = z.union([localUserSchema, cloudUserSchema]);
+const userSchema = userFileSchema;
+const setUserSchema = userSchema;
+
+//#endregion
+//#region src/schema/cliSchema.ts
+const outDirSchema = z$1.string().default("./.elek.io");
+const languageSchema = z$1.enum(["ts", "js"]).default("ts");
+const formatSchema = z$1.enum(["esm", "cjs"]).default("esm");
+const targetSchema = z$1.enum([
+	"es3",
+	"es5",
+	"es6",
+	"es2015",
+	"es2016",
+	"es2017",
+	"es2018",
+	"es2019",
+	"es2020",
+	"es2021",
+	"es2022",
+	"es2023",
+	"es2024",
+	"esnext"
+]).default("es2020");
+const projectsSchema = z$1.string().default("all").transform((value) => {
+	if (value === "all") return "all";
+	return value.split(",").map((v) => uuidSchema.parse(v.trim()));
+});
+const generateApiClientOptionsSchema = z$1.object({ watch: z$1.boolean().default(false) });
+const exportProjectsOptionsSchema = generateApiClientOptionsSchema.extend({ separate: z$1.boolean().default(false) });
+const generateApiClientSchema = z$1.object({
+	outDir: outDirSchema,
+	language: languageSchema,
+	format: formatSchema,
+	target: targetSchema,
+	options: generateApiClientOptionsSchema
+});
+const portSchema = z$1.string().default("31310").transform((value, context) => {
+	try {
+		return parseInt(value);
+	} catch (_error) {
+		context.addIssue({
+			code: "custom",
+			message: "Invalid port number",
+			input: value
+		});
+		return z$1.NEVER;
+	}
+});
+const apiStartSchema = z$1.object({ port: portSchema });
+const exportSchema = z$1.object({
+	outDir: outDirSchema,
+	projects: projectsSchema,
+	options: exportProjectsOptionsSchema
+});
+
+//#endregion
+//#region src/schema/logSchema.ts
+const logSourceSchema = z.enum(["core", "desktop"]);
+const logSchema = z.object({
+	source: logSourceSchema,
+	message: z.string(),
+	meta: z.record(z.string(), z.unknown()).optional()
+});
+const logConsoleTransportSchema = logSchema.extend({
+	timestamp: z.string(),
+	level: z.string()
+});
+
+//#endregion
+//#region src/api/routes/content/v1/projects.ts
+const tags$3 = ["Content API v1"];
+const router$6 = createRouter().openapi(createRoute({
+	summary: "List Projects",
+	description: "Lists all Projects you currently have access to",
+	method: "get",
+	path: "/",
+	tags: tags$3,
+	request: { query: z.object({
+		limit: z.string().pipe(z.coerce.number()).optional().openapi({
+			default: 15,
+			description: "The maximum number of Projects to return"
+		}),
+		offset: z.string().pipe(z.coerce.number()).optional().openapi({
+			default: 0,
+			description: "The number of Projects to skip before starting to collect the result set"
+		})
+	}) },
+	responses: { [200]: {
+		content: { "application/json": { schema: paginatedListOf(projectSchema) } },
+		description: "A list of Projects you have access to"
+	} }
+}), async (c) => {
+	const { limit, offset } = c.req.valid("query");
+	const projects = await c.var.projectService.list({
+		limit,
+		offset
+	});
+	return c.json(projects, 200);
+}).openapi(createRoute({
+	summary: "Count Projects",
+	description: "Counts all Projects you currently have access to",
+	method: "get",
+	path: "/count",
+	tags: tags$3,
+	responses: { [200]: {
+		content: { "application/json": { schema: z.number() } },
+		description: "The number of Projects you have access to"
+	} }
+}), async (c) => {
+	const count = await c.var.projectService.count();
+	return c.json(count, 200);
+}).openapi(createRoute({
+	summary: "Get one Project",
+	description: "Retrieve a Project by ID",
+	method: "get",
+	path: "/{projectId}",
+	tags: tags$3,
+	request: { params: z.object({ projectId: uuidSchema.openapi({ param: {
+		name: "projectId",
+		in: "path"
+	} }) }) },
+	responses: { [200]: {
+		content: { "application/json": { schema: projectSchema } },
+		description: "The requested Project"
+	} }
+}), async (c) => {
+	const { projectId } = c.req.valid("param");
+	const project = await c.var.projectService.read({ id: projectId });
+	return c.json(project, 200);
+});
+var projects_default = router$6;
+
+//#endregion
+//#region src/api/routes/content/v1/collections.ts
+const tags$2 = ["Content API v1"];
+const router$5 = createRouter().openapi(createRoute({
+	summary: "List Collections",
+	description: "Lists all Collections of the given Project",
+	method: "get",
+	path: "/{projectId}/collections",
+	tags: tags$2,
+	request: {
+		params: z.object({ projectId: uuidSchema.openapi({ param: {
+			name: "projectId",
+			in: "path"
+		} }) }),
+		query: z.object({
+			limit: z.string().pipe(z.coerce.number()).optional().openapi({
+				default: "15",
+				description: "The maximum number of Collections to return"
+			}),
+			offset: z.string().pipe(z.coerce.number()).optional().openapi({
+				default: "0",
+				description: "The number of Collections to skip before starting to collect the result set"
+			})
+		})
+	},
+	responses: { [200]: {
+		content: { "application/json": { schema: paginatedListOf(collectionSchema) } },
+		description: "A list of Collections for the given Project"
+	} }
+}), async (c) => {
+	const { projectId } = c.req.valid("param");
+	const { limit, offset } = c.req.valid("query");
+	const collections = await c.var.collectionService.list({
+		projectId,
+		limit,
+		offset
+	});
+	return c.json(collections, 200);
+}).openapi(createRoute({
+	summary: "Count Collections",
+	description: "Counts all Collections of the given Project",
+	method: "get",
+	path: "/{projectId}/collections/count",
+	tags: tags$2,
+	request: { params: z.object({ projectId: uuidSchema.openapi({ param: {
+		name: "projectId",
+		in: "path"
+	} }) }) },
+	responses: { [200]: {
+		content: { "application/json": { schema: z.number() } },
+		description: "The number of Collections of the given Project"
+	} }
+}), async (c) => {
+	const { projectId } = c.req.valid("param");
+	const count = await c.var.collectionService.count({ projectId });
+	return c.json(count, 200);
+}).openapi(createRoute({
+	summary: "Get one Collection",
+	description: "Retrieve a Collection by ID",
+	method: "get",
+	path: "/{projectId}/collections/{collectionId}",
+	tags: tags$2,
+	request: { params: z.object({
+		projectId: uuidSchema.openapi({ param: {
+			name: "projectId",
+			in: "path"
+		} }),
+		collectionId: uuidSchema.openapi({ param: {
+			name: "collectionId",
+			in: "path"
+		} })
+	}) },
+	responses: { [200]: {
+		content: { "application/json": { schema: collectionSchema } },
+		description: "The requested Collection"
+	} }
+}), async (c) => {
+	const { projectId, collectionId } = c.req.valid("param");
+	const collection = await c.var.collectionService.read({
+		projectId,
+		id: collectionId
+	});
+	return c.json(collection, 200);
+});
+var collections_default = router$5;
+
+//#endregion
+//#region src/api/routes/content/v1/entries.ts
+const tags$1 = ["Content API v1"];
+const router$4 = createRouter().openapi(createRoute({
+	summary: "List Entries",
+	description: "Lists all Entries of the given Projects Collection",
+	method: "get",
+	path: "/{projectId}/collections/{collectionId}/entries",
+	tags: tags$1,
+	request: {
+		params: z.object({
+			projectId: uuidSchema.openapi({ param: {
+				name: "projectId",
+				in: "path"
+			} }),
+			collectionId: uuidSchema.openapi({ param: {
+				name: "collectionId",
+				in: "path"
+			} })
+		}),
+		query: z.object({
+			limit: z.string().pipe(z.coerce.number()).optional().openapi({
+				default: "15",
+				description: "The maximum number of Entries to return"
+			}),
+			offset: z.string().pipe(z.coerce.number()).optional().openapi({
+				default: "0",
+				description: "The number of Entries to skip before starting to collect the result set"
+			})
+		})
+	},
+	responses: { [200]: {
+		content: { "application/json": { schema: paginatedListOf(entrySchema) } },
+		description: "A list of Entries for the given Projects Collection"
+	} }
+}), async (c) => {
+	const { projectId, collectionId } = c.req.valid("param");
+	const { limit, offset } = c.req.valid("query");
+	const entries = await c.var.entryService.list({
+		projectId,
+		collectionId,
+		limit,
+		offset
+	});
+	return c.json(entries, 200);
+}).openapi(createRoute({
+	summary: "Count Entries",
+	description: "Counts all Entries of the given Projects Collection",
+	method: "get",
+	path: "/{projectId}/collections/{collectionId}/entries/count",
+	tags: tags$1,
+	request: { params: z.object({
+		projectId: uuidSchema.openapi({ param: {
+			name: "projectId",
+			in: "path"
+		} }),
+		collectionId: uuidSchema.openapi({ param: {
+			name: "collectionId",
+			in: "path"
+		} })
+	}) },
+	responses: { [200]: {
+		content: { "application/json": { schema: z.number() } },
+		description: "The number of Entries of the given Projects Collection"
+	} }
+}), async (c) => {
+	const { projectId, collectionId } = c.req.valid("param");
+	const count = await c.var.entryService.count({
+		projectId,
+		collectionId
+	});
+	return c.json(count, 200);
+}).openapi(createRoute({
+	summary: "Get one Entry",
+	description: "Retrieve an Entry by ID",
+	method: "get",
+	path: "/{projectId}/collections/{collectionId}/entries/{entryId}",
+	tags: tags$1,
+	request: { params: z.object({
+		projectId: uuidSchema.openapi({ param: {
+			name: "projectId",
+			in: "path"
+		} }),
+		collectionId: uuidSchema.openapi({ param: {
+			name: "collectionId",
+			in: "path"
+		} }),
+		entryId: uuidSchema.openapi({ param: {
+			name: "entryId",
+			in: "path"
+		} })
+	}) },
+	responses: { [200]: {
+		content: { "application/json": { schema: entrySchema } },
+		description: "The requested Entry"
+	} }
+}), async (c) => {
+	const { projectId, collectionId, entryId } = c.req.valid("param");
+	const entry = await c.var.entryService.read({
+		projectId,
+		collectionId,
+		id: entryId
+	});
+	return c.json(entry, 200);
+});
+var entries_default = router$4;
+
+//#endregion
+//#region src/api/routes/content/v1/assets.ts
+const tags = ["Content API v1"];
+const router$3 = createRouter().openapi(createRoute({
+	summary: "List Assets",
+	description: "Lists all Assets of the given Project",
+	method: "get",
+	path: "/{projectId}/assets",
+	tags,
+	request: {
+		params: z.object({ projectId: uuidSchema.openapi({ param: {
+			name: "projectId",
+			in: "path"
+		} }) }),
+		query: z.object({
+			limit: z.string().pipe(z.coerce.number()).optional().openapi({
+				default: "15",
+				description: "The maximum number of Assets to return"
+			}),
+			offset: z.string().pipe(z.coerce.number()).optional().openapi({
+				default: "0",
+				description: "The number of Assets to skip before starting to collect the result set"
+			})
+		})
+	},
+	responses: { [200]: {
+		content: { "application/json": { schema: paginatedListOf(assetSchema) } },
+		description: "A list of Assets for the given Project"
+	} }
+}), async (c) => {
+	const { projectId } = c.req.valid("param");
+	const { limit, offset } = c.req.valid("query");
+	const assets = await c.var.assetService.list({
+		projectId,
+		limit,
+		offset
+	});
+	return c.json(assets, 200);
+}).openapi(createRoute({
+	summary: "Count Assets",
+	description: "Counts all Assets of the given Project",
+	method: "get",
+	path: "/{projectId}/assets/count",
+	tags,
+	request: { params: z.object({ projectId: uuidSchema.openapi({ param: {
+		name: "projectId",
+		in: "path"
+	} }) }) },
+	responses: { [200]: {
+		content: { "application/json": { schema: z.number() } },
+		description: "The number of Assets of the given Project"
+	} }
+}), async (c) => {
+	const { projectId } = c.req.valid("param");
+	const count = await c.var.assetService.count({ projectId });
+	return c.json(count, 200);
+}).openapi(createRoute({
+	summary: "Get one Asset",
+	description: "Retrieve an Asset by ID",
+	method: "get",
+	path: "/{projectId}/assets/{assetId}",
+	tags,
+	request: { params: z.object({
+		projectId: uuidSchema.openapi({ param: {
+			name: "projectId",
+			in: "path"
+		} }),
+		assetId: uuidSchema.openapi({ param: {
+			name: "assetId",
+			in: "path"
+		} })
+	}) },
+	responses: { [200]: {
+		content: { "application/json": { schema: assetSchema } },
+		description: "The requested Asset"
+	} }
+}), async (c) => {
+	const { projectId, assetId } = c.req.valid("param");
+	const asset = await c.var.assetService.read({
+		projectId,
+		id: assetId
+	});
+	return c.json(asset, 200);
+});
+var assets_default = router$3;
+
+//#endregion
+//#region src/api/routes/content/v1/index.ts
+const router$2 = createRouter().route("/projects", projects_default).route("/projects", collections_default).route("/projects", entries_default).route("/projects", assets_default);
+var v1_default = router$2;
+
+//#endregion
+//#region src/api/routes/content/index.ts
+const router$1 = createRouter().route("/v1", v1_default);
+var content_default = router$1;
+
+//#endregion
+//#region src/api/routes/index.ts
+const router = createRouter().route("/content", content_default);
+var routes_default = router;
+
+//#endregion
+//#region src/api/index.ts
+var LocalApi = class {
+	logService;
+	projectService;
+	collectionService;
+	entryService;
+	assetService;
+	api;
+	server = null;
+	constructor(logService, projectService, collectionService, entryService, assetService) {
+		this.logService = logService;
+		this.projectService = projectService;
+		this.collectionService = collectionService;
+		this.entryService = entryService;
+		this.assetService = assetService;
+		this.api = createApi(this.logService, this.projectService, this.collectionService, this.entryService, this.assetService).route("/", routes_default).doc("/openapi.json", {
+			openapi: "3.0.0",
+			externalDocs: { url: "https://elek.io/docs" },
+			info: {
+				version: "0.1.0",
+				title: "elek.io local API",
+				description: "This API allows reading content from local elek.io Projects. You can use this API for development and building static websites and applications locally."
+			},
+			servers: [{
+				url: "http://localhost:{port}",
+				description: "elek.io local API",
+				variables: { port: {
+					default: 31310,
+					description: "The port specified in elek.io Clients user configuration"
+				} }
+			}],
+			tags: [{
+				name: "Content API v1",
+				description: "Version 1 of the elek.io content API lets you read Projects, Collections, Entries and Assets. \n### Resources\n - [Projects](https://elek.io/docs/projects)\n - [Collections](https://elek.io/docs/collections)\n - [Entries](https://elek.io/docs/entries)\n - [Assets](https://elek.io/docs/assets)"
+			}]
+		});
+		this.api.get("/", Scalar({
+			pageTitle: "elek.io local API",
+			url: "/openapi.json",
+			theme: "kepler",
+			layout: "modern",
+			defaultHttpClient: {
+				targetKey: "js",
+				clientKey: "fetch"
+			}
+		}));
+	}
+	/**
+	* Starts the local API on given port
+	*/
+	start(port) {
+		this.server = serve({
+			fetch: this.api.fetch,
+			port
+		}, (info) => {
+			this.logService.info({
+				source: "core",
+				message: `Started local API on http://localhost:${info.port}`
+			});
+		});
+	}
+	/**
+	* Stops the local API
+	*/
+	stop() {
+		this.server?.close(() => {
+			this.logService.info({
+				source: "core",
+				message: "Stopped local API"
+			});
+		});
+	}
+	/**
+	* Returns true if the local API is running
+	*/
+	isRunning() {
+		if (this.server?.listening) return true;
+		return false;
+	}
+};
+
+//#endregion
+//#region src/error/GitError.ts
+var GitError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "GitError";
+	}
+};
+
+//#endregion
+//#region src/error/NoCurrentUserError.ts
+var NoCurrentUserError = class extends Error {
+	constructor() {
+		super("Make sure to set a User via Core before using other methods");
+		this.name = "NoCurrentUserError";
+	}
+};
+
+//#endregion
+//#region src/error/ProjectUpgradeError.ts
+var ProjectUpgradeError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ProjectUpgradeError";
+	}
+};
+
+//#endregion
+//#region src/error/RequiredParameterMissingError.ts
+var RequiredParameterMissingError = class extends Error {
+	constructor(parameter) {
+		super(`Missing required parameter "${parameter}"`);
+		this.name = "RequiredParameterMissingError";
+	}
+};
+
+//#endregion
+//#region src/util/node.ts
+var node_exports = /* @__PURE__ */ __export({
+	execCommand: () => execCommand,
+	files: () => files,
+	folders: () => folders,
+	isNotAnError: () => isNotAnError,
+	isNotEmpty: () => isNotEmpty,
+	pathTo: () => pathTo,
+	workingDirectory: () => workingDirectory
+});
+/**
+* The directory in which everything is stored and will be worked in
+*
+* @todo make the workingDirectory an elek option to be set via app.getPath('home') (electron instead of node)?
+*/
+const workingDirectory = Path.join(Os.homedir(), "elek.io");
+/**
+* A collection of often used paths
+*/
+const pathTo = {
+	tmp: Path.join(workingDirectory, "tmp"),
+	userFile: Path.join(workingDirectory, "user.json"),
+	logs: Path.join(workingDirectory, "logs"),
+	projects: Path.join(workingDirectory, "projects"),
+	project: (projectId) => {
+		return Path.join(pathTo.projects, projectId);
+	},
+	projectFile: (projectId) => {
+		return Path.join(pathTo.project(projectId), "project.json");
+	},
+	lfs: (projectId) => {
+		return Path.join(pathTo.project(projectId), projectFolderSchema.enum.lfs);
+	},
+	collections: (projectId) => {
+		return Path.join(pathTo.project(projectId), projectFolderSchema.enum.collections);
+	},
+	collection: (projectId, id) => {
+		return Path.join(pathTo.collections(projectId), id);
+	},
+	collectionFile: (projectId, id) => {
+		return Path.join(pathTo.collection(projectId, id), "collection.json");
+	},
+	entries: (projectId, collectionId) => {
+		return Path.join(pathTo.collection(projectId, collectionId));
+	},
+	entryFile: (projectId, collectionId, id) => {
+		return Path.join(pathTo.entries(projectId, collectionId), `${id}.json`);
+	},
+	sharedValues: (projectId) => {
+		return Path.join(pathTo.project(projectId), "shared-values");
+	},
+	sharedValueFile: (projectId, id, language) => {
+		return Path.join(pathTo.sharedValues(projectId), `${id}.${language}.json`);
+	},
+	assets: (projectId) => {
+		return Path.join(pathTo.project(projectId), projectFolderSchema.enum.assets);
+	},
+	assetFile: (projectId, id) => {
+		return Path.join(pathTo.assets(projectId), `${id}.json`);
+	},
+	asset: (projectId, id, extension) => {
+		return Path.join(pathTo.lfs(projectId), `${id}.${extension}`);
+	},
+	tmpAsset: (id, commitHash, extension) => {
+		return Path.join(pathTo.tmp, `${id}.${commitHash}.${extension}`);
+	}
+};
+/**
+* Used as parameter for filter() methods to assure,
+* only values not null, undefined or empty strings are returned
+*
+* @param value Value to check
+*/
+function isNotEmpty(value) {
+	if (value === null || value === void 0) return false;
+	if (typeof value === "string") {
+		if (value.trim() === "") return false;
+	}
+	return true;
+}
+/**
+* Used as parameter for filter() methods to assure,
+* only items that are not of type Error are returned
+*
+* @param item Item to check
+*/
+function isNotAnError(item) {
+	return item instanceof Error !== true;
+}
+/**
+* Returns all folders of given path to a directory
+*/
+async function folders(path) {
+	return (await Fs.readdir(path, { withFileTypes: true })).filter((dirent) => {
+		return dirent.isDirectory();
+	});
+}
+/**
+* Returns all files of given path to a directory,
+* which can be filtered by extension
+*/
+async function files(path, extension) {
+	return (await Fs.readdir(path, { withFileTypes: true })).filter((dirent) => {
+		if (extension && dirent.isFile() === true) {
+			if (dirent.name.endsWith(extension)) return true;
+			return false;
+		}
+		return dirent.isFile();
+	});
+}
+/**
+* Executes a shell command async and returns the output.
+*
+* When on Windows, it will automatically append `.cmd` to the command if it is in the `commandsToSuffix` list.
+*/
+function execCommand({ command, args, options, logger }) {
+	return new Promise((resolve, reject) => {
+		const commandsToSuffix = ["pnpm"];
+		const suffixedCommand = Os.platform() === "win32" ? command.split(" ").map((cmd) => commandsToSuffix.includes(cmd) ? `${cmd}.cmd` : cmd).join(" ") : command;
+		const fullCommand = `${suffixedCommand} ${args.join(" ")}`;
+		const execOptions = {
+			...options,
+			shell: true
+		};
+		const start = Date.now();
+		execFile(suffixedCommand, args, execOptions, (error, stdout, stderr) => {
+			const durationMs = Date.now() - start;
+			if (error) {
+				logger.error({
+					source: "core",
+					message: `Error executing command "${fullCommand}" after ${durationMs}ms: ${error.message}`,
+					meta: {
+						error,
+						stdout: stdout.toString(),
+						stderr: stderr.toString()
+					}
+				});
+				reject(error instanceof Error ? error : new Error(error.message));
+			} else {
+				logger.info({
+					source: "core",
+					message: `Command "${fullCommand}" executed successfully in ${durationMs}ms.`,
+					meta: {
+						stdout: stdout.toString(),
+						stderr: stderr.toString()
+					}
+				});
+				resolve({
+					stdout: stdout.toString(),
+					stderr: stderr.toString()
+				});
+			}
+		});
+	});
+}
+
+//#endregion
+//#region src/service/AbstractCrudService.ts
+/**
+* A base service that provides properties for most other services
+*/
+var AbstractCrudService = class {
+	type;
+	options;
+	logService;
+	/**
+	* Do not instantiate directly as this is an abstract class
+	*/
+	constructor(type$1, options, logService) {
+		this.type = type$1;
+		this.options = options;
+		this.logService = logService;
+	}
+	/**
+	* Basically a Promise.all() without rejecting if one promise fails to resolve
+	*/
+	async returnResolved(promises) {
+		const toCheck = [];
+		for (let index = 0; index < promises.length; index++) {
+			const promise = promises[index];
+			if (!promise) throw new Error(`No promise found at index "${index}"`);
+			toCheck.push(promise.then((result) => {
+				return result;
+			}).catch((error) => {
+				const actualError = error instanceof Error ? error : new Error(String(error));
+				this.logService.warn({
+					source: "core",
+					message: `Function "returnResolved" catched an error while resolving a promise: ${actualError.message}`,
+					meta: {
+						error: actualError,
+						promise
+					}
+				});
+				return actualError;
+			}));
+		}
+		return (await Promise.all(toCheck)).filter(isNotAnError);
+	}
+	/**
+	* Returns a list of all file references of given project and type
+	*
+	* @param type File type of the references wanted
+	* @param projectId Project to get all asset references from
+	* @param collectionId Only needed when requesting files of type "Entry"
+	*/
+	async listReferences(type$1, projectId, collectionId) {
+		switch (type$1) {
+			case objectTypeSchema.enum.asset:
+				if (!projectId) throw new RequiredParameterMissingError("projectId");
+				return this.getFileReferences(pathTo.lfs(projectId));
+			case objectTypeSchema.enum.project: return this.getFolderReferences(pathTo.projects);
+			case objectTypeSchema.enum.collection:
+				if (!projectId) throw new RequiredParameterMissingError("projectId");
+				return this.getFolderReferences(pathTo.collections(projectId));
+			case objectTypeSchema.enum.entry:
+				if (!projectId) throw new RequiredParameterMissingError("projectId");
+				if (!collectionId) throw new RequiredParameterMissingError("collectionId");
+				return this.getFileReferences(pathTo.collection(projectId, collectionId));
+			case objectTypeSchema.enum.sharedValue:
+				if (!projectId) throw new RequiredParameterMissingError("projectId");
+				return this.getFileReferences(pathTo.sharedValues(projectId));
+			default: throw new Error(`Trying to list files of unsupported type "${type$1}"`);
+		}
+	}
+	async getFolderReferences(path) {
+		return (await folders(path)).map((possibleFolder) => {
+			const folderReference = { id: possibleFolder.name };
+			try {
+				return fileReferenceSchema.parse(folderReference);
+			} catch {
+				this.logService.warn({
+					source: "core",
+					message: `Function "getFolderReferences" is ignoring folder "${possibleFolder.name}" in "${path}" as it does not match the expected format`
+				});
+				return null;
+			}
+		}).filter(isNotEmpty);
+	}
+	/**
+	* Searches for all files inside given folder,
+	* parses their names and returns them as FileReference
+	*
+	* Ignores files if the extension is not supported.
+	*/
+	async getFileReferences(path) {
+		return (await files(path)).map((possibleFile) => {
+			const fileNameArray = possibleFile.name.split(".");
+			const fileReference = {
+				id: fileNameArray[0],
+				extension: fileNameArray[1]
+			};
+			try {
+				return fileReferenceSchema.parse(fileReference);
+			} catch {
+				this.logService.warn({
+					source: "core",
+					message: `Function "getFileReferences" is ignoring file "${possibleFile.name}" in "${path}" as it does not match the expected format`
+				});
+				return null;
+			}
+		}).filter(isNotEmpty);
+	}
+};
+
+//#endregion
+//#region src/util/shared.ts
+/**
+* Returns a new UUID
+*/
+function uuid() {
+	return v4();
+}
+/**
+* Returns a string representing date and time
+* in a simplified format based on ISO 8601.
+* The timezone is always UTC.
+*
+* - If value is not given, the current date and time is used
+* - If value is given, it's converted to above representation and UTC timezone
+*
+* @example 'YYYY-MM-DDTHH:mm:ss.sssZ'
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString
+* @see https://en.wikipedia.org/wiki/ISO_8601
+*/
+function datetime(value) {
+	if (!value) return (/* @__PURE__ */ new Date()).toISOString();
+	return new Date(value).toISOString();
+}
+/**
+* Returns the slug of given string
+*/
+function slug(string) {
+	return slugify(string, {
+		separator: "-",
+		lowercase: true,
+		decamelize: true
+	});
+}
+
+//#endregion
+//#region src/service/AssetService.ts
+/**
+* Service that manages CRUD functionality for Asset files on disk
+*/
+var AssetService = class extends AbstractCrudService {
+	jsonFileService;
+	gitService;
+	constructor(options, logService, jsonFileService, gitService) {
+		super(serviceTypeSchema.enum.Asset, options, logService);
+		this.jsonFileService = jsonFileService;
+		this.gitService = gitService;
+	}
+	/**
+	* Creates a new Asset
+	*/
+	async create(props) {
+		createAssetSchema.parse(props);
+		const id = uuid();
+		const projectPath = pathTo.project(props.projectId);
+		const fileType = this.getFileType(props.filePath);
+		const size = await this.getFileSize(props.filePath);
+		const assetPath = pathTo.asset(props.projectId, id, fileType.extension);
+		const assetFilePath = pathTo.assetFile(props.projectId, id);
+		const assetFile = {
+			...props,
+			name: slug(props.name),
+			objectType: "asset",
+			id,
+			created: datetime(),
+			updated: null,
+			extension: fileType.extension,
+			mimeType: fileType.mimeType,
+			size
+		};
+		try {
+			await Fs.copyFile(props.filePath, assetPath);
+			await this.jsonFileService.create(assetFile, assetFilePath, assetFileSchema);
+		} catch (error) {
+			await this.delete({
+				...assetFile,
+				projectId: props.projectId
+			});
+			throw error;
+		}
+		await this.gitService.add(projectPath, [assetFilePath, assetPath]);
+		await this.gitService.commit(projectPath, {
+			method: "create",
+			reference: {
+				objectType: "asset",
+				id
+			}
+		});
+		return this.toAsset(props.projectId, assetFile);
+	}
+	/**
+	* Returns an Asset by ID
+	*
+	* If a commit hash is provided, the Asset is read from history
+	*/
+	async read(props) {
+		readAssetSchema.parse(props);
+		if (!props.commitHash) {
+			const assetFile = await this.jsonFileService.read(pathTo.assetFile(props.projectId, props.id), assetFileSchema);
+			return this.toAsset(props.projectId, assetFile);
+		} else {
+			const assetFile = this.migrate(JSON.parse(await this.gitService.getFileContentAtCommit(pathTo.project(props.projectId), pathTo.assetFile(props.projectId, props.id), props.commitHash)));
+			const assetBlob = await this.gitService.getFileContentAtCommit(pathTo.project(props.projectId), pathTo.asset(props.projectId, props.id, assetFile.extension), props.commitHash, "binary");
+			await Fs.writeFile(pathTo.tmpAsset(assetFile.id, props.commitHash, assetFile.extension), assetBlob, "binary");
+			return this.toAsset(props.projectId, assetFile, props.commitHash);
+		}
+	}
+	/**
+	* Copies an Asset to given file path on disk
+	*/
+	async save(props) {
+		saveAssetSchema.parse(props);
+		const asset = await this.read(props);
+		await Fs.copyFile(asset.absolutePath, props.filePath);
+	}
+	/**
+	* Updates given Asset
+	*
+	* Use the optional "newFilePath" prop to update the Asset itself
+	*/
+	async update(props) {
+		updateAssetSchema.parse(props);
+		const projectPath = pathTo.project(props.projectId);
+		const assetFilePath = pathTo.assetFile(props.projectId, props.id);
+		const prevAssetFile = await this.read(props);
+		const assetFile = {
+			...prevAssetFile,
+			...props,
+			name: slug(props.name),
+			updated: datetime()
+		};
+		if (props.newFilePath) {
+			const fileType = this.getFileType(props.newFilePath);
+			const size = await this.getFileSize(props.newFilePath);
+			const prevAssetPath = pathTo.asset(props.projectId, props.id, prevAssetFile.extension);
+			const assetPath = pathTo.asset(props.projectId, props.id, fileType.extension);
+			await Fs.remove(prevAssetPath);
+			await Fs.copyFile(props.newFilePath, assetPath);
+			await this.gitService.add(projectPath, [prevAssetPath, assetPath]);
+			assetFile.extension = fileType.extension;
+			assetFile.mimeType = fileType.mimeType;
+			assetFile.size = size;
+		}
+		await this.jsonFileService.update(assetFile, assetFilePath, assetFileSchema);
+		await this.gitService.add(projectPath, [assetFilePath]);
+		await this.gitService.commit(projectPath, {
+			method: "update",
+			reference: {
+				objectType: "asset",
+				id: assetFile.id
+			}
+		});
+		return this.toAsset(props.projectId, assetFile);
+	}
+	/**
+	* Deletes given Asset
+	*/
+	async delete(props) {
+		deleteAssetSchema.parse(props);
+		const projectPath = pathTo.project(props.projectId);
+		const assetFilePath = pathTo.assetFile(props.projectId, props.id);
+		const assetPath = pathTo.asset(props.projectId, props.id, props.extension);
+		await Fs.remove(assetPath);
+		await Fs.remove(assetFilePath);
+		await this.gitService.add(projectPath, [assetFilePath, assetPath]);
+		await this.gitService.commit(projectPath, {
+			method: "delete",
+			reference: {
+				objectType: "asset",
+				id: props.id
+			}
+		});
+	}
+	async list(props) {
+		listAssetsSchema.parse(props);
+		const offset = props.offset || 0;
+		const limit = props.limit || 15;
+		const assetReferences = await this.listReferences(objectTypeSchema.enum.asset, props.projectId);
+		const partialAssetReferences = assetReferences.slice(offset, limit);
+		const assets = await this.returnResolved(partialAssetReferences.map((assetReference) => {
+			return this.read({
+				projectId: props.projectId,
+				id: assetReference.id
+			});
+		}));
+		return {
+			total: assetReferences.length,
+			limit,
+			offset,
+			list: assets
+		};
+	}
+	async count(props) {
+		countAssetsSchema.parse(props);
+		return (await this.listReferences(objectTypeSchema.enum.asset, props.projectId)).length;
+	}
+	/**
+	* Checks if given object is of type Asset
+	*/
+	isAsset(obj) {
+		return assetSchema.safeParse(obj).success;
+	}
+	/**
+	* Returns the size of an file in bytes
+	*
+	* @param path Path of the file to get the size from
+	*/
+	async getFileSize(path) {
+		return (await Fs.stat(path)).size;
+	}
+	/**
+	* Creates an Asset from given AssetFile
+	*
+	* @param projectId   The project's ID
+	* @param assetFile   The AssetFile to convert
+	*/
+	async toAsset(projectId, assetFile, commitHash) {
+		const assetPath = commitHash ? pathTo.tmpAsset(assetFile.id, commitHash, assetFile.extension) : pathTo.asset(projectId, assetFile.id, assetFile.extension);
+		const history = await this.gitService.log(pathTo.project(projectId), { filePath: pathTo.assetFile(projectId, assetFile.id) });
+		return {
+			...assetFile,
+			absolutePath: assetPath,
+			history
+		};
+	}
+	/**
+	* Returns the found and supported extension as well as mime type,
+	* otherwise throws an error
+	*
+	* @param filePath Path to the file to check
+	*/
+	getFileType(filePath) {
+		const mimeType = mime.getType(filePath);
+		if (mimeType === null) throw new Error(`Unsupported MIME type of file "${filePath}"`);
+		const extension = mime.getExtension(mimeType);
+		if (extension === null) throw new Error(`Unsupported extension for MIME type "${mimeType}" of file "${filePath}"`);
+		return {
+			extension,
+			mimeType
+		};
+	}
+	/**
+	* Migrates an potentially outdated Asset file to the current schema
+	*/
+	migrate(potentiallyOutdatedAssetFile) {
+		return assetFileSchema.parse(potentiallyOutdatedAssetFile);
+	}
+};
+
+//#endregion
+//#region src/service/CollectionService.ts
+/**
+* Service that manages CRUD functionality for Collection files on disk
+*/
+var CollectionService = class extends AbstractCrudService {
+	jsonFileService;
+	gitService;
+	constructor(options, logService, jsonFileService, gitService) {
+		super(serviceTypeSchema.enum.Collection, options, logService);
+		this.jsonFileService = jsonFileService;
+		this.gitService = gitService;
+	}
+	/**
+	* Creates a new Collection
+	*/
+	async create(props) {
+		createCollectionSchema.parse(props);
+		const id = uuid();
+		const projectPath = pathTo.project(props.projectId);
+		const collectionPath = pathTo.collection(props.projectId, id);
+		const collectionFilePath = pathTo.collectionFile(props.projectId, id);
+		const collectionFile = {
+			...props,
+			objectType: "collection",
+			id,
+			slug: {
+				singular: slug(props.slug.singular),
+				plural: slug(props.slug.plural)
+			},
+			created: datetime(),
+			updated: null
+		};
+		await Fs.ensureDir(collectionPath);
+		await this.jsonFileService.create(collectionFile, collectionFilePath, collectionFileSchema);
+		await this.gitService.add(projectPath, [collectionFilePath]);
+		await this.gitService.commit(projectPath, {
+			method: "create",
+			reference: {
+				objectType: "collection",
+				id
+			}
+		});
+		return this.toCollection(props.projectId, collectionFile);
+	}
+	/**
+	* Returns a Collection by ID
+	*
+	* If a commit hash is provided, the Collection is read from history
+	*/
+	async read(props) {
+		readCollectionSchema.parse(props);
+		if (!props.commitHash) {
+			const collectionFile = await this.jsonFileService.read(pathTo.collectionFile(props.projectId, props.id), collectionFileSchema);
+			return this.toCollection(props.projectId, collectionFile);
+		} else {
+			const collectionFile = this.migrate(JSON.parse(await this.gitService.getFileContentAtCommit(pathTo.project(props.projectId), pathTo.collectionFile(props.projectId, props.id), props.commitHash)));
+			return this.toCollection(props.projectId, collectionFile);
+		}
+	}
+	/**
+	* Updates given Collection
+	*
+	* @todo finish implementing checks for FieldDefinitions and extract methods
+	*
+	* @param projectId   Project ID of the collection to update
+	* @param collection  Collection to write to disk
+	* @returns           An object containing information about the actions needed to be taken,
+	*                    before given update can be executed or void if the update was executed successfully
+	*/
+	async update(props) {
+		updateCollectionSchema.parse(props);
+		const projectPath = pathTo.project(props.projectId);
+		const collectionFilePath = pathTo.collectionFile(props.projectId, props.id);
+		const collectionFile = {
+			...await this.read(props),
+			...props,
+			updated: datetime()
+		};
+		await this.jsonFileService.update(collectionFile, collectionFilePath, collectionFileSchema);
+		await this.gitService.add(projectPath, [collectionFilePath]);
+		await this.gitService.commit(projectPath, {
+			method: "update",
+			reference: {
+				objectType: "collection",
+				id: collectionFile.id
+			}
+		});
+		return this.toCollection(props.projectId, collectionFile);
+	}
+	/**
+	* Deletes given Collection (folder), including it's items
+	*
+	* The Fields that Collection used are not deleted.
+	*/
+	async delete(props) {
+		deleteCollectionSchema.parse(props);
+		const projectPath = pathTo.project(props.projectId);
+		const collectionPath = pathTo.collection(props.projectId, props.id);
+		await Fs.remove(collectionPath);
+		await this.gitService.add(projectPath, [collectionPath]);
+		await this.gitService.commit(projectPath, {
+			method: "delete",
+			reference: {
+				objectType: "collection",
+				id: props.id
+			}
+		});
+	}
+	async list(props) {
+		listCollectionsSchema.parse(props);
+		const offset = props.offset || 0;
+		const limit = props.limit || 15;
+		const collectionReferences = await this.listReferences(objectTypeSchema.enum.collection, props.projectId);
+		const partialCollectionReferences = collectionReferences.slice(offset, limit);
+		const collections = await this.returnResolved(partialCollectionReferences.map((reference) => {
+			return this.read({
+				projectId: props.projectId,
+				id: reference.id
+			});
+		}));
+		return {
+			total: collectionReferences.length,
+			limit,
+			offset,
+			list: collections
+		};
+	}
+	async count(props) {
+		countCollectionsSchema.parse(props);
+		return (await this.listReferences(objectTypeSchema.enum.collection, props.projectId)).length;
+	}
+	/**
+	* Checks if given object is of type Collection
+	*/
+	isCollection(obj) {
+		return collectionFileSchema.safeParse(obj).success;
+	}
+	/**
+	* Migrates an potentially outdated Collection file to the current schema
+	*/
+	migrate(potentiallyOutdatedCollectionFile) {
+		return collectionFileSchema.parse(potentiallyOutdatedCollectionFile);
+	}
+	/**
+	* Creates an Collection from given CollectionFile
+	*
+	* @param projectId   The project's ID
+	* @param collectionFile   The CollectionFile to convert
+	*/
+	async toCollection(projectId, collectionFile) {
+		const history = await this.gitService.log(pathTo.project(projectId), { filePath: pathTo.collectionFile(projectId, collectionFile.id) });
+		return {
+			...collectionFile,
+			history
+		};
+	}
+};
+
+//#endregion
+//#region src/service/EntryService.ts
+/**
+* Service that manages CRUD functionality for Entry files on disk
+*/
+var EntryService = class extends AbstractCrudService {
+	jsonFileService;
+	gitService;
+	collectionService;
+	constructor(options, logService, jsonFileService, gitService, collectionService) {
+		super(serviceTypeSchema.enum.Entry, options, logService);
+		this.jsonFileService = jsonFileService;
+		this.gitService = gitService;
+		this.collectionService = collectionService;
+	}
+	/**
+	* Creates a new Entry for given Collection
+	*/
+	async create(props) {
+		createEntrySchema.parse(props);
+		const id = uuid();
+		const projectPath = pathTo.project(props.projectId);
+		const entryFilePath = pathTo.entryFile(props.projectId, props.collectionId, id);
+		const collection = await this.collectionService.read({
+			projectId: props.projectId,
+			id: props.collectionId
+		});
+		const entryFile = {
+			objectType: "entry",
+			id,
+			values: props.values,
+			created: datetime(),
+			updated: null
+		};
+		const entry = await this.toEntry(props.projectId, props.collectionId, entryFile);
+		getCreateEntrySchemaFromFieldDefinitions(collection.fieldDefinitions).parse(props);
+		await this.jsonFileService.create(entryFile, entryFilePath, entryFileSchema);
+		await this.gitService.add(projectPath, [entryFilePath]);
+		await this.gitService.commit(projectPath, {
+			method: "create",
+			reference: {
+				objectType: "entry",
+				id: entryFile.id,
+				collectionId: props.collectionId
+			}
+		});
+		return entry;
+	}
+	/**
+	* Returns an Entry from given Collection by ID
+	*
+	* If a commit hash is provided, the Entry is read from history
+	*/
+	async read(props) {
+		readEntrySchema.parse(props);
+		if (!props.commitHash) {
+			const entryFile = await this.jsonFileService.read(pathTo.entryFile(props.projectId, props.collectionId, props.id), entryFileSchema);
+			return this.toEntry(props.projectId, props.collectionId, entryFile);
+		} else {
+			const entryFile = this.migrate(JSON.parse(await this.gitService.getFileContentAtCommit(pathTo.project(props.projectId), pathTo.entryFile(props.projectId, props.collectionId, props.id), props.commitHash)));
+			return this.toEntry(props.projectId, props.collectionId, entryFile);
+		}
+	}
+	/**
+	* Updates an Entry of given Collection with new Values and shared Values
+	*/
+	async update(props) {
+		updateEntrySchema.parse(props);
+		const projectPath = pathTo.project(props.projectId);
+		const entryFilePath = pathTo.entryFile(props.projectId, props.collectionId, props.id);
+		const collection = await this.collectionService.read({
+			projectId: props.projectId,
+			id: props.collectionId
+		});
+		const entryFile = {
+			...await this.read({
+				projectId: props.projectId,
+				collectionId: props.collectionId,
+				id: props.id
+			}),
+			values: props.values,
+			updated: datetime()
+		};
+		const entry = await this.toEntry(props.projectId, props.collectionId, entryFile);
+		getUpdateEntrySchemaFromFieldDefinitions(collection.fieldDefinitions).parse(props);
+		await this.jsonFileService.update(entryFile, entryFilePath, entryFileSchema);
+		await this.gitService.add(projectPath, [entryFilePath]);
+		await this.gitService.commit(projectPath, {
+			method: "update",
+			reference: {
+				objectType: "entry",
+				id: entryFile.id,
+				collectionId: props.collectionId
+			}
+		});
+		return entry;
+	}
+	/**
+	* Deletes given Entry from it's Collection
+	*/
+	async delete(props) {
+		deleteEntrySchema.parse(props);
+		const projectPath = pathTo.project(props.projectId);
+		const entryFilePath = pathTo.entryFile(props.projectId, props.collectionId, props.id);
+		await Fs.remove(entryFilePath);
+		await this.gitService.add(projectPath, [entryFilePath]);
+		await this.gitService.commit(projectPath, {
+			method: "delete",
+			reference: {
+				objectType: "entry",
+				id: props.id,
+				collectionId: props.collectionId
+			}
+		});
+	}
+	async list(props) {
+		listEntriesSchema.parse(props);
+		const offset = props.offset || 0;
+		const limit = props.limit || 15;
+		const entryReferences = await this.listReferences(objectTypeSchema.enum.entry, props.projectId, props.collectionId);
+		const partialEntryReferences = entryReferences.slice(offset, limit);
+		const entries = await this.returnResolved(partialEntryReferences.map((reference) => {
+			return this.read({
+				projectId: props.projectId,
+				collectionId: props.collectionId,
+				id: reference.id
+			});
+		}));
+		return {
+			total: entryReferences.length,
+			limit,
+			offset,
+			list: entries
+		};
+	}
+	async count(props) {
+		countEntriesSchema.parse(props);
+		return (await this.listReferences(objectTypeSchema.enum.entry, props.projectId, props.collectionId)).length;
+	}
+	/**
+	* Checks if given object is of type Entry
+	*/
+	isEntry(obj) {
+		return entrySchema.safeParse(obj).success;
+	}
+	/**
+	* Migrates an potentially outdated Entry file to the current schema
+	*/
+	migrate(potentiallyOutdatedEntryFile) {
+		return entryFileSchema.parse(potentiallyOutdatedEntryFile);
+	}
+	/**
+	* Creates an Entry from given EntryFile by resolving it's Values
+	*/
+	async toEntry(projectId, collectionId, entryFile) {
+		const history = await this.gitService.log(pathTo.project(projectId), { filePath: pathTo.entryFile(projectId, collectionId, entryFile.id) });
+		return {
+			...entryFile,
+			history
+		};
+	}
+};
+
+//#endregion
+//#region src/service/GitTagService.ts
+/**
+* Service that manages CRUD functionality for GitTags
+*/
+var GitTagService = class extends AbstractCrudService {
+	git;
+	constructor(options, git, logService) {
+		super(serviceTypeSchema.enum.GitTag, options, logService);
+		this.git = git;
+	}
+	/**
+	* Creates a new tag
+	*
+	* @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---annotate
+	*/
+	async create(props) {
+		createGitTagSchema.parse(props);
+		const id = uuid();
+		let args = [
+			"tag",
+			"--annotate",
+			id
+		];
+		if (props.hash) args = [...args, props.hash];
+		args = [
+			...args,
+			"-m",
+			props.message
+		];
+		await this.git(props.path, args);
+		return await this.read({
+			path: props.path,
+			id
+		});
+	}
+	/**
+	* Returns a tag by ID
+	*
+	* Internally uses list() but only returns the tag with matching ID.
+	*/
+	async read(props) {
+		readGitTagSchema.parse(props);
+		const tag = (await this.list({ path: props.path })).list.find((tag$1) => {
+			return tag$1.id === props.id;
+		});
+		if (!tag) throw new GitError(`Provided tag with UUID "${props.id}" did not match any known tags`);
+		return tag;
+	}
+	/**
+	* Updating a git tag is not supported.
+	* Please delete the old and create a new one
+	*
+	* @deprecated
+	* @see https://git-scm.com/docs/git-tag#_on_re_tagging
+	*/
+	update() {
+		throw new Error("Updating a git tag is not supported. Please delete the old and create a new one");
+	}
+	/**
+	* Deletes a tag
+	*
+	* @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---delete
+	*
+	* @param path  Path to the repository
+	* @param id    UUID of the tag to delete
+	*/
+	async delete(props) {
+		deleteGitTagSchema.parse(props);
+		const args = [
+			"tag",
+			"--delete",
+			props.id
+		];
+		await this.git(props.path, args);
+	}
+	/**
+	* Gets all local tags or filter them by pattern
+	*
+	* They are sorted by authordate of the commit, not when the tag is created.
+	* This ensures tags are sorted correctly in the timeline of their commits.
+	*
+	* @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---list
+	*/
+	async list(props) {
+		listGitTagsSchema.parse(props);
+		let args = ["tag", "--list"];
+		args = [
+			...args,
+			"--sort=-*authordate",
+			"--format=%(refname:short)|%(subject)|%(*authorname)|%(*authoremail)|%(*authordate:iso-strict)"
+		];
+		const gitTags = (await this.git(props.path, args)).stdout.split("\n").filter((line) => {
+			return line.trim() !== "";
+		}).map((line) => {
+			const lineArray = line.split("|");
+			if (lineArray[3]?.startsWith("<") && lineArray[3]?.endsWith(">")) {
+				lineArray[3] = lineArray[3].slice(1, -1);
+				lineArray[3] = lineArray[3].slice(0, -1);
+			}
+			return {
+				id: lineArray[0],
+				message: lineArray[1],
+				author: {
+					name: lineArray[2],
+					email: lineArray[3]
+				},
+				datetime: datetime(lineArray[4])
+			};
+		}).filter(this.isGitTag.bind(this));
+		return {
+			total: gitTags.length,
+			limit: 0,
+			offset: 0,
+			list: gitTags
+		};
+	}
+	/**
+	* Returns the total number of tags inside given repository
+	*
+	* Internally uses list(), so do not use count()
+	* in conjuncion with it to avoid multiple git calls.
+	*
+	* @param path Path to the repository
+	*/
+	async count(props) {
+		countGitTagsSchema.parse(props);
+		return (await this.list({ path: props.path })).total;
+	}
+	/**
+	* Type guard for GitTag
+	*
+	* @param obj The object to check
+	*/
+	isGitTag(obj) {
+		return gitTagSchema.safeParse(obj).success;
+	}
+};
+
+//#endregion
+//#region src/service/GitService.ts
+/**
+* Service that manages Git functionality
+*
+* Uses dugite Node.js bindings for Git to be fully compatible
+* and be able to leverage Git LFS functionality
+* @see https://github.com/desktop/dugite
+*
+* Heavily inspired by the GitHub Desktop app
+* @see https://github.com/desktop/desktop
+*
+* Git operations are sequential!
+* We use a FIFO queue to translate async calls
+* into a sequence of git operations
+*
+* @todo All public methods should recieve only a single object as parameter and the type should be defined through the shared library to be accessible in Core and Client
+*/
+var GitService = class {
+	version;
+	gitPath;
+	queue;
+	logService;
+	gitTagService;
+	userService;
+	constructor(options, logService, userService) {
+		this.version = null;
+		this.gitPath = null;
+		this.queue = new PQueue({ concurrency: 1 });
+		this.gitTagService = new GitTagService(options, this.git.bind(this), logService);
+		this.logService = logService;
+		this.userService = userService;
+		this.updateVersion();
+		this.updateGitPath();
+	}
+	/**
+	* CRUD methods to work with git tags
+	*/
+	get tags() {
+		return this.gitTagService;
+	}
+	/**
+	* Create an empty Git repository or reinitialize an existing one
+	*
+	* @see https://git-scm.com/docs/git-init
+	*
+	* @param path    Path to initialize in. Fails if path does not exist
+	* @param options Options specific to the init operation
+	*/
+	async init(path, options) {
+		let args = ["init"];
+		if (options?.initialBranch) args = [...args, `--initial-branch=${options.initialBranch}`];
+		await this.git(path, args);
+		await this.setLocalConfig(path);
+	}
+	/**
+	* Clone a repository into a directory
+	*
+	* @see https://git-scm.com/docs/git-clone
+	*
+	* @todo Implement progress callback / events
+	*
+	* @param url     The remote repository URL to clone from
+	* @param path    The destination path for the cloned repository.
+	*                Which is only working if the directory is existing and empty.
+	* @param options Options specific to the clone operation
+	*/
+	async clone(url, path, options) {
+		let args = ["clone", "--progress"];
+		if (options?.bare) args = [...args, "--bare"];
+		if (options?.branch) args = [
+			...args,
+			"--branch",
+			options.branch
+		];
+		if (options?.depth) args = [
+			...args,
+			"--depth",
+			options.depth.toString()
+		];
+		if (options?.singleBranch === true) args = [...args, "--single-branch"];
+		await this.git("", [
+			...args,
+			url,
+			path
+		]);
+		await this.setLocalConfig(path);
+	}
+	/**
+	* Add file contents to the index
+	*
+	* @see https://git-scm.com/docs/git-add
+	*
+	* @param path  Path to the repository
+	* @param files Files to add
+	*/
+	async add(path, files$2) {
+		const args = [
+			"add",
+			"--",
+			...files$2.map((filePath) => {
+				return filePath.replace(`${path}${Path.sep}`, "");
+			})
+		];
+		await this.git(path, args);
+	}
+	async status(path) {
+		return (await this.git(path, ["status", "--porcelain=2"])).stdout.split("\n").filter((line) => {
+			return line.trim() !== "";
+		}).map((line) => {
+			return { filePath: line.trim().split(" ")[8] };
+		});
+	}
+	branches = {
+		list: async (path) => {
+			const normalizedLinesArr = (await this.git(path, [
+				"branch",
+				"--list",
+				"--all"
+			])).stdout.split("\n").filter((line) => {
+				return line.trim() !== "";
+			}).map((line) => {
+				return line.trim().replace("* ", "");
+			});
+			const local = [];
+			const remote = [];
+			normalizedLinesArr.forEach((line) => {
+				if (line.startsWith("remotes/")) remote.push(line.replace("remotes/", ""));
+				else local.push(line);
+			});
+			return {
+				local,
+				remote
+			};
+		},
+		current: async (path) => {
+			return (await this.git(path, ["branch", "--show-current"])).stdout.trim();
+		},
+		switch: async (path, branch, options) => {
+			await this.checkBranchOrTagName(path, branch);
+			let args = ["switch"];
+			if (options?.isNew === true) args = [
+				...args,
+				"--create",
+				branch
+			];
+			else args = [...args, branch];
+			await this.git(path, args);
+		},
+		delete: async (path, branch, force) => {
+			let args = ["branch", "--delete"];
+			if (force === true) args = [...args, "--force"];
+			await this.git(path, [...args, branch]);
+		}
+	};
+	remotes = {
+		list: async (path) => {
+			return (await this.git(path, ["remote"])).stdout.split("\n").filter((line) => {
+				return line.trim() !== "";
+			});
+		},
+		hasOrigin: async (path) => {
+			if ((await this.remotes.list(path)).includes("origin")) return true;
+			return false;
+		},
+		addOrigin: async (path, url) => {
+			const args = [
+				"remote",
+				"add",
+				"origin",
+				url.trim()
+			];
+			await this.git(path, args);
+		},
+		getOriginUrl: async (path) => {
+			const result = (await this.git(path, [
+				"remote",
+				"get-url",
+				"origin"
+			])).stdout.trim();
+			return result.length === 0 ? null : result;
+		},
+		setOriginUrl: async (path, url) => {
+			const args = [
+				"remote",
+				"set-url",
+				"origin",
+				url.trim()
+			];
+			await this.git(path, args);
+		}
+	};
+	/**
+	* Join two development histories together
+	*
+	* @see https://git-scm.com/docs/git-merge
+	*/
+	async merge(path, branch, options) {
+		let args = ["merge"];
+		if (options?.squash === true) args = [...args, "--squash"];
+		args = [...args, branch];
+		await this.git(path, args);
+	}
+	/**
+	* Reset current HEAD to the specified state
+	*
+	* @todo maybe add more options
+	* @see https://git-scm.com/docs/git-reset
+	*
+	* @param path    Path to the repository
+	* @param mode    Modifies the working tree depending on given mode
+	* @param commit  Resets the current branch head to this commit / tag
+	*/
+	async reset(path, mode, commit) {
+		const args = [
+			"reset",
+			`--${mode}`,
+			commit
+		];
+		await this.git(path, args);
+	}
+	/**
+	* Restore working tree files
+	*
+	* @see https://git-scm.com/docs/git-restore/
+	*
+	* @todo It's probably a good idea to not use restore
+	* for a use case where someone just wants to have a look
+	* and maybe copy something from a deleted file.
+	* We should use `checkout` without `add .` and `commit` for that
+	*
+	* @param path    Path to the repository
+	* @param source  Git commit SHA or tag name to restore to
+	* @param files   Files to restore
+	*/
+	/**
+	* Download objects and refs from remote `origin`
+	*
+	* @see https://www.git-scm.com/docs/git-fetch
+	*
+	* @param path Path to the repository
+	*/
+	async fetch(path) {
+		await this.git(path, ["fetch"]);
+	}
+	/**
+	* Fetch from and integrate (rebase or merge) with a local branch
+	*
+	* @see https://git-scm.com/docs/git-pull
+	*
+	* @param path Path to the repository
+	*/
+	async pull(path) {
+		await this.git(path, ["pull"]);
+	}
+	/**
+	* Update remote refs along with associated objects to remote `origin`
+	*
+	* @see https://git-scm.com/docs/git-push
+	*
+	* @param path Path to the repository
+	*/
+	async push(path, options) {
+		let args = ["push", "origin"];
+		if (options?.all === true) args = [...args, "--all"];
+		if (options?.force === true) args = [...args, "--force"];
+		await this.git(path, args);
+	}
+	/**
+	* Record changes to the repository
+	*
+	* @see https://git-scm.com/docs/git-commit
+	*
+	* @param path    Path to the repository
+	* @param message An object describing the changes
+	*/
+	async commit(path, message) {
+		gitMessageSchema.parse(message);
+		const user = await this.userService.get();
+		if (!user) throw new NoCurrentUserError();
+		const args = [
+			"commit",
+			`--message=${JSON.stringify(message)}`,
+			`--author=${user.name} <${user.email}>`
+		];
+		await this.git(path, args);
+	}
+	/**
+	* Gets local commit history
+	*
+	* @see https://git-scm.com/docs/git-log
+	*
+	* @todo Check if there is a need to trim the git commit message of chars
+	* @todo Use this method in a service. Decide if we need a HistoryService for example
+	*
+	* @param path    Path to the repository
+	* @param options Options specific to the log operation
+	*/
+	async log(path, options) {
+		let args = ["log"];
+		if (options?.between?.from) args = [...args, `${options.between.from}..${options.between.to || "HEAD"}`];
+		if (options?.limit) args = [...args, `--max-count=${options.limit}`];
+		args = [...args, "--format=%H|%s|%an|%ae|%aI|%D"];
+		if (options?.filePath) args = [
+			...args,
+			"--",
+			options.filePath
+		];
+		const noEmptyLinesArr = (await this.git(path, args)).stdout.split("\n").filter((line) => {
+			return line.trim() !== "";
+		});
+		return (await Promise.all(noEmptyLinesArr.map(async (line) => {
+			const lineArray = line.split("|");
+			const tagId = this.refNameToTagName(lineArray[5] || "");
+			const tag = tagId ? await this.tags.read({
+				path,
+				id: tagId
+			}) : null;
+			return {
+				hash: lineArray[0],
+				message: JSON.parse(lineArray[1] || ""),
+				author: {
+					name: lineArray[2],
+					email: lineArray[3]
+				},
+				datetime: datetime(lineArray[4]),
+				tag
+			};
+		}))).filter(this.isGitCommit.bind(this));
+	}
+	/**
+	* Retrieves the content of a file at a specific commit
+	*
+	* @see https://git-scm.com/docs/git-show
+	*/
+	async getFileContentAtCommit(path, filePath, commitHash, encoding = "utf8") {
+		const args = ["show", `${commitHash}:${filePath.replace(`${path}${Path.sep}`, "").split("\\").join("/")}`];
+		const setEncoding = (cb) => {
+			if (cb.stdout) cb.stdout.setEncoding(encoding);
+		};
+		return (await this.git(path, args, { processCallback: setEncoding })).stdout;
+	}
+	refNameToTagName(refName) {
+		const tagName = refName.replace("tag: ", "").trim();
+		if (tagName === "" || uuidSchema.safeParse(tagName).success === false) return null;
+		return tagName;
+	}
+	/**
+	* Reads the currently used version of Git
+	*
+	* This can help debugging
+	*/
+	async updateVersion() {
+		this.version = (await this.git("", ["--version"])).stdout.replace("git version", "").trim();
+	}
+	/**
+	* Reads the path to the executable of Git that is used
+	*
+	* This can help debugging, since dugite is shipping their own executable
+	* but in some cases resolves another executable
+	* @see https://github.com/desktop/dugite/blob/main/lib/git-environment.ts
+	*/
+	async updateGitPath() {
+		this.gitPath = (await this.git("", ["--exec-path"])).stdout.trim();
+	}
+	/**
+	* A reference is used in Git to specify branches and tags.
+	* This method checks if given name matches the required format
+	*
+	* @see https://git-scm.com/docs/git-check-ref-format
+	*
+	* @param path Path to the repository
+	* @param name Name to check
+	*/
+	async checkBranchOrTagName(path, name$1) {
+		await this.git(path, [
+			"check-ref-format",
+			"--allow-onelevel",
+			name$1
+		]);
+	}
+	/**
+	* Sets the git config of given local repository from ElekIoCoreOptions
+	*
+	* @param path Path to the repository
+	*/
+	async setLocalConfig(path) {
+		const user = await this.userService.get();
+		if (!user) throw new NoCurrentUserError();
+		const userNameArgs = [
+			"config",
+			"--local",
+			"user.name",
+			user.name
+		];
+		const userEmailArgs = [
+			"config",
+			"--local",
+			"user.email",
+			user.email
+		];
+		const autoSetupRemoteArgs = [
+			"config",
+			"--local",
+			"push.autoSetupRemote",
+			"true"
+		];
+		const pullRebaseArgs = [
+			"config",
+			"--local",
+			"pull.rebase",
+			"true"
+		];
+		await this.git(path, userNameArgs);
+		await this.git(path, userEmailArgs);
+		await this.git(path, autoSetupRemoteArgs);
+		await this.git(path, pullRebaseArgs);
+	}
+	/**
+	* Type guard for GitCommit
+	*
+	* @param obj The object to check
+	*/
+	isGitCommit(obj) {
+		return gitCommitSchema.safeParse(obj).success;
+	}
+	/**
+	* Wraps the execution of any git command
+	* to use a FIFO queue for sequential processing
+	*
+	* @param path Path to the repository
+	* @param args Arguments to append after the `git` command
+	*/
+	async git(path, args, options) {
+		const result = await this.queue.add(async () => {
+			const start = Date.now();
+			return {
+				gitResult: await GitProcess.exec(args, path, options),
+				durationMs: Date.now() - start
+			};
+		});
+		if (!result) throw new GitError(`Git ${this.version} (${this.gitPath}) command "git ${args.join(" ")}" executed for "${path}" failed to return a result`);
+		const gitLog = {
+			source: "core",
+			message: `Executed "git ${args.join(" ")}" in ${result.durationMs}ms`,
+			meta: { command: `git ${args.join(" ")}` }
+		};
+		if (result.durationMs >= 100) this.logService.warn(gitLog);
+		else this.logService.debug(gitLog);
+		if (result.gitResult.exitCode !== 0) throw new GitError(`Git ${this.version} (${this.gitPath}) command "git ${args.join(" ")}" executed for "${path}" failed with exit code "${result.gitResult.exitCode}" and message "${result.gitResult.stderr.trim() || result.gitResult.stdout.trim()}"`);
+		return result.gitResult;
+	}
+};
+
+//#endregion
+//#region src/service/JsonFileService.ts
+/**
+* Service that manages CRUD functionality for JSON files on disk
+*/
+var JsonFileService = class extends AbstractCrudService {
+	cache = /* @__PURE__ */ new Map();
+	constructor(options, logService) {
+		super(serviceTypeSchema.enum.JsonFile, options, logService);
+	}
+	/**
+	* Creates a new file on disk. Fails if path already exists
+	*
+	* @param data Data to write into the file
+	* @param path Path to write the file to
+	* @param schema Schema of the file to validate against
+	* @returns Validated content of the file from disk
+	*/
+	async create(data, path, schema) {
+		const parsedData = schema.parse(data);
+		const string = this.serialize(parsedData);
+		await Fs.writeFile(path, string, {
+			flag: "wx",
+			encoding: "utf8"
+		});
+		if (this.options.file.cache === true) this.cache.set(path, parsedData);
+		this.logService.debug({
+			source: "core",
+			message: `Created file "${path}"`
+		});
+		return parsedData;
+	}
+	/**
+	* Reads the content of a file on disk. Fails if path does not exist
+	*
+	* @param path Path to read the file from
+	* @param schema Schema of the file to validate against
+	* @returns Validated content of the file from disk
+	*/
+	async read(path, schema) {
+		if (this.options.file.cache === true && this.cache.has(path)) {
+			this.logService.debug({
+				source: "core",
+				message: `Cache hit reading file "${path}"`
+			});
+			const json$1 = this.cache.get(path);
+			return schema.parse(json$1);
+		}
+		this.logService.debug({
+			source: "core",
+			message: `Cache miss reading file "${path}"`
+		});
+		const data = await Fs.readFile(path, {
+			flag: "r",
+			encoding: "utf8"
+		});
+		const json = this.deserialize(data);
+		const parsedData = schema.parse(json);
+		if (this.options.file.cache === true) this.cache.set(path, parsedData);
+		return parsedData;
+	}
+	/**
+	* Reads the content of a file on disk. Fails if path does not exist.
+	* Does not validate the content of the file against a schema and
+	* therefore is only to be used when retrieving data we do not have
+	* a current schema for. E.g. reading from history or while upgrading
+	* the old schema of a file to a new, current schema.
+	*
+	* Does not read from or write to cache.
+	*
+	* @param path Path to read the file from
+	* @returns Unvalidated content of the file from disk
+	*/
+	async unsafeRead(path) {
+		this.logService.warn({
+			source: "core",
+			message: `Unsafe reading of file "${path}"`
+		});
+		const data = await Fs.readFile(path, {
+			flag: "r",
+			encoding: "utf8"
+		});
+		return this.deserialize(data);
+	}
+	/**
+	* Overwrites an existing file on disk
+	*
+	* @todo Check how to error out if the file does not exist already
+	*
+	* @param data Data to write into the file
+	* @param path Path to the file to overwrite
+	* @param schema Schema of the file to validate against
+	* @returns Validated content of the file from disk
+	*/
+	async update(data, path, schema) {
+		const parsedData = schema.parse(data);
+		const string = this.serialize(parsedData);
+		await Fs.writeFile(path, string, {
+			flag: "w",
+			encoding: "utf8"
+		});
+		if (this.options.file.cache === true) this.cache.set(path, parsedData);
+		this.logService.debug({
+			source: "core",
+			message: `Updated file "${path}"`
+		});
+		return parsedData;
+	}
+	serialize(data) {
+		return JSON.stringify(data, null, 2);
+	}
+	deserialize(data) {
+		return JSON.parse(data);
+	}
+};
+
+//#endregion
+//#region src/service/LogService.ts
+/**
+* Service that handles logging to file and console
+*/
+var LogService = class {
+	logger;
+	constructor(options) {
+		const rotatingFileTransport = new DailyRotateFile({
+			dirname: pathTo.logs,
+			filename: "%DATE%.log",
+			datePattern: "YYYY-MM-DD",
+			zippedArchive: true,
+			maxFiles: "30d",
+			handleExceptions: true,
+			handleRejections: true,
+			format: format.combine(format.timestamp(), format.json())
+		});
+		rotatingFileTransport.on("rotate", (oldFilename, newFilename) => {
+			this.info({
+				message: `Rotated log file from ${oldFilename} to ${newFilename}`,
+				source: "core"
+			});
+		});
+		rotatingFileTransport.on("error", (error) => {
+			this.error({
+				message: `Error rotating log file: ${error.message}`,
+				source: "core",
+				meta: { error }
+			});
+		});
+		const consoleTransport = new transports.Console({
+			handleExceptions: true,
+			handleRejections: true,
+			format: format.combine(format.colorize(), format.timestamp({ format: "HH:mm:ss" }), format.printf((props) => {
+				const { timestamp, level, source, message } = logConsoleTransportSchema.parse({
+					...props[Symbol.for("splat")][0],
+					timestamp: props["timestamp"],
+					level: props.level,
+					message: props.message
+				});
+				return `${timestamp} [${source}] ${level}: ${message}`;
+			}))
+		});
+		this.logger = createLogger({
+			level: options.log.level,
+			transports: [rotatingFileTransport, consoleTransport]
+		});
+	}
+	debug(props) {
+		const { source, message, meta } = logSchema.parse(props);
+		this.logger.debug(message, {
+			source,
+			meta
+		});
+	}
+	info(props) {
+		const { source, message, meta } = logSchema.parse(props);
+		this.logger.info(message, {
+			source,
+			meta
+		});
+	}
+	warn(props) {
+		const { source, message, meta } = logSchema.parse(props);
+		this.logger.warn(message, {
+			source,
+			meta
+		});
+	}
+	error(props) {
+		const { source, message, meta } = logSchema.parse(props);
+		this.logger.error(message, {
+			source,
+			meta
+		});
+	}
+};
+
+//#endregion
+//#region src/error/RemoteOriginMissingError.ts
+var RemoteOriginMissingError = class extends Error {
+	constructor(projectId) {
+		super(`Tried to delete Project "${projectId}" but it does not have a remote origin. Deleting a Project without a remote origin could lead to data loss. Use the "force" option to delete it anyway.`);
+		this.name = "RemoteOriginMissingError";
+	}
+};
+
+//#endregion
+//#region src/error/SynchronizeLocalChangesError.ts
+var SynchronizeLocalChangesError = class extends Error {
+	constructor(projectId) {
+		super(`Tried to delete Project "${projectId}" but it has local changes that are not yet pushed to the remote origin. Deleting a Project with local changes could lead to data loss. Use the "force" option to delete it anyway.`);
+		this.name = "SynchronizeLocalChangesError";
+	}
+};
+
+//#endregion
+//#region src/service/ProjectService.ts
+/**
+* Service that manages CRUD functionality for Project files on disk
+*/
+var ProjectService = class extends AbstractCrudService {
+	coreVersion;
+	jsonFileService;
+	userService;
+	gitService;
+	assetService;
+	collectionService;
+	entryService;
+	constructor(coreVersion, options, logService, jsonFileService, userService, gitService, assetService, collectionService, entryService) {
+		super(serviceTypeSchema.enum.Project, options, logService);
+		this.coreVersion = coreVersion;
+		this.jsonFileService = jsonFileService;
+		this.userService = userService;
+		this.gitService = gitService;
+		this.assetService = assetService;
+		this.collectionService = collectionService;
+		this.entryService = entryService;
+	}
+	/**
+	* Creates a new Project
+	*/
+	async create(props) {
+		createProjectSchema.parse(props);
+		const user = await this.userService.get();
+		if (!user) throw new NoCurrentUserError();
+		const id = uuid();
+		const defaultSettings = { language: {
+			default: user.language,
+			supported: [user.language]
+		} };
+		const projectFile = {
+			...props,
+			objectType: "project",
+			id,
+			description: props.description || "",
+			settings: Object.assign({}, defaultSettings, props.settings),
+			created: datetime(),
+			updated: null,
+			coreVersion: this.coreVersion,
+			status: "todo",
+			version: "0.0.1"
+		};
+		const projectPath = pathTo.project(id);
+		await Fs.ensureDir(projectPath);
+		try {
+			await this.createFolderStructure(projectPath);
+			await this.createGitignore(projectPath);
+			await this.gitService.init(projectPath, { initialBranch: projectBranchSchema.enum.production });
+			await this.jsonFileService.create(projectFile, pathTo.projectFile(id), projectFileSchema);
+			await this.gitService.add(projectPath, ["."]);
+			await this.gitService.commit(projectPath, {
+				method: "create",
+				reference: {
+					objectType: "project",
+					id
+				}
+			});
+			await this.gitService.branches.switch(projectPath, projectBranchSchema.enum.work, { isNew: true });
+		} catch (error) {
+			await this.delete({
+				id,
+				force: true
+			});
+			throw error;
+		}
+		return await this.toProject(projectFile);
+	}
+	/**
+	* Clones a Project by URL
+	*/
+	async clone(props) {
+		cloneProjectSchema.parse(props);
+		const tmpId = uuid();
+		const tmpProjectPath = Path.join(pathTo.tmp, tmpId);
+		await this.gitService.clone(props.url, tmpProjectPath);
+		const projectFile = await this.jsonFileService.read(Path.join(tmpProjectPath, "project.json"), projectFileSchema);
+		const projectPath = pathTo.project(projectFile.id);
+		if (await Fs.pathExists(projectPath)) throw new Error(`Tried to clone Project "${projectFile.id}" from "${props.url}" - but the Project already exists locally`);
+		await Fs.copy(tmpProjectPath, projectPath);
+		await Fs.remove(tmpProjectPath);
+		return await this.toProject(projectFile);
+	}
+	/**
+	* Returns a Project by ID
+	*
+	* If a commit hash is provided, the Project is read from history
+	*/
+	async read(props) {
+		readProjectSchema.parse(props);
+		if (!props.commitHash) {
+			const projectFile = await this.jsonFileService.read(pathTo.projectFile(props.id), projectFileSchema);
+			return await this.toProject(projectFile);
+		} else {
+			const projectFile = this.migrate(JSON.parse(await this.gitService.getFileContentAtCommit(pathTo.project(props.id), pathTo.projectFile(props.id), props.commitHash)));
+			return await this.toProject(projectFile);
+		}
+	}
+	/**
+	* Updates given Project
+	*/
+	async update(props) {
+		updateProjectSchema.parse(props);
+		const projectPath = pathTo.project(props.id);
+		const filePath = pathTo.projectFile(props.id);
+		const prevProjectFile = await this.read(props);
+		const projectFile = {
+			...prevProjectFile,
+			name: props.name || prevProjectFile.name,
+			description: props.description || prevProjectFile.description,
+			coreVersion: this.coreVersion,
+			settings: { language: {
+				supported: props.settings?.language.supported || prevProjectFile.settings.language.supported,
+				default: props.settings?.language.default || prevProjectFile.settings.language.default
+			} },
+			updated: datetime()
+		};
+		await this.jsonFileService.update(projectFile, filePath, projectFileSchema);
+		await this.gitService.add(projectPath, [filePath]);
+		await this.gitService.commit(projectPath, {
+			method: "update",
+			reference: {
+				objectType: "project",
+				id: projectFile.id
+			}
+		});
+		return await this.toProject(projectFile);
+	}
+	/**
+	* Upgrades given Project to the current version of Core
+	*
+	* Needed when a new Core version is requiring changes to existing files or structure.
+	*/
+	async upgrade(props) {
+		upgradeProjectSchema.parse(props);
+		const projectPath = pathTo.project(props.id);
+		const projectFilePath = pathTo.projectFile(props.id);
+		if (await this.gitService.branches.current(projectPath) !== projectBranchSchema.enum.work) await this.gitService.branches.switch(projectPath, projectBranchSchema.enum.work);
+		const currentProjectFile = outdatedProjectSchema.passthrough().parse(await this.jsonFileService.unsafeRead(projectFilePath));
+		if (Semver.gt(currentProjectFile.coreVersion, this.coreVersion)) throw new ProjectUpgradeError(`The Projects Core version "${currentProjectFile.coreVersion}" is higher than the current Core version "${this.coreVersion}".`);
+		if (Semver.eq(currentProjectFile.coreVersion, this.coreVersion) && props.force !== true) throw new ProjectUpgradeError(`The Projects Core version "${currentProjectFile.coreVersion}" is already up to date.`);
+		const assetReferences = await this.listReferences("asset", props.id);
+		const collectionReferences = await this.listReferences("collection", props.id);
+		this.logService.info({
+			source: "core",
+			message: `Attempting to upgrade Project "${props.id}" from Core version ${currentProjectFile.coreVersion} to ${this.coreVersion}`
+		});
+		const upgradeBranchName = `upgrade/core-${currentProjectFile.coreVersion}-to-${this.coreVersion}`;
+		await this.gitService.branches.switch(projectPath, upgradeBranchName, { isNew: true });
+		try {
+			await Promise.all(assetReferences.map(async (reference) => {
+				await this.upgradeObjectFile(props.id, "asset", reference);
+			}));
+			await Promise.all(collectionReferences.map(async (reference) => {
+				await this.upgradeObjectFile(props.id, "collection", reference);
+			}));
+			await Promise.all(collectionReferences.map(async (collectionReference) => {
+				const entryReferences = await this.listReferences("entry", props.id, collectionReference.id);
+				await Promise.all(entryReferences.map(async (reference) => {
+					await this.upgradeObjectFile(props.id, "entry", reference, collectionReference.id);
+				}));
+			}));
+			const migratedProjectFile = this.migrate(currentProjectFile);
+			await this.update(migratedProjectFile);
+			await this.gitService.branches.switch(projectPath, projectBranchSchema.enum.work);
+			await this.gitService.merge(projectPath, upgradeBranchName, { squash: true });
+			await this.gitService.commit(projectPath, {
+				method: "upgrade",
+				reference: {
+					objectType: "project",
+					id: migratedProjectFile.id
+				}
+			});
+			await this.gitService.tags.create({
+				path: projectPath,
+				message: `Upgraded Project to Core version ${migratedProjectFile.coreVersion}`
+			});
+			await this.gitService.branches.delete(projectPath, upgradeBranchName, true);
+			this.logService.info({
+				source: "core",
+				message: `Successfully upgraded Project "${props.id}" to Core version "${this.coreVersion}"`,
+				meta: {
+					previous: currentProjectFile,
+					migrated: migratedProjectFile
+				}
+			});
+		} catch (error) {
+			await this.gitService.branches.switch(projectPath, projectBranchSchema.enum.work);
+			await this.gitService.branches.delete(projectPath, upgradeBranchName, true);
+			throw error;
+		}
+	}
+	branches = {
+		list: async (props) => {
+			listBranchesProjectSchema.parse(props);
+			const projectPath = pathTo.project(props.id);
+			if (await this.gitService.remotes.hasOrigin(projectPath)) await this.gitService.fetch(projectPath);
+			return await this.gitService.branches.list(projectPath);
+		},
+		current: async (props) => {
+			currentBranchProjectSchema.parse(props);
+			const projectPath = pathTo.project(props.id);
+			return await this.gitService.branches.current(projectPath);
+		},
+		switch: async (props) => {
+			switchBranchProjectSchema.parse(props);
+			const projectPath = pathTo.project(props.id);
+			return await this.gitService.branches.switch(projectPath, props.branch, props.options);
+		}
+	};
+	/**
+	* Updates the remote origin URL of given Project
+	*
+	* @todo maybe add this logic to the update method
+	*/
+	async setRemoteOriginUrl(props) {
+		setRemoteOriginUrlProjectSchema.parse(props);
+		const projectPath = pathTo.project(props.id);
+		if (!await this.gitService.remotes.hasOrigin(projectPath)) await this.gitService.remotes.addOrigin(projectPath, props.url);
+		else await this.gitService.remotes.setOriginUrl(projectPath, props.url);
+	}
+	/**
+	* Returns the differences of the given Projects current branch
+	* between the local and remote `origin` (commits ahead & behind)
+	*
+	* Throws an error if the Project does not have a remote origin.
+	*
+	* - `behind` contains a list of commits on the current branch that are available on the remote `origin` but not yet locally
+	* - `ahead` contains a list of commits on the current branch that are available locally but not yet on the remote `origin`
+	*/
+	async getChanges(props) {
+		getChangesProjectSchema.parse(props);
+		const projectPath = pathTo.project(props.id);
+		if (await this.gitService.remotes.hasOrigin(projectPath) === false) throw new Error(`Project "${props.id}" does not have a remote origin`);
+		const currentBranch = await this.gitService.branches.current(projectPath);
+		await this.gitService.fetch(projectPath);
+		return {
+			behind: await this.gitService.log(projectPath, { between: {
+				from: currentBranch,
+				to: `origin/${currentBranch}`
+			} }),
+			ahead: await this.gitService.log(projectPath, { between: {
+				from: `origin/${currentBranch}`,
+				to: currentBranch
+			} })
+		};
+	}
+	/**
+	* Pulls remote changes of `origin` down to the local repository
+	* and then pushes local commits to the upstream branch
+	*/
+	async synchronize(props) {
+		synchronizeProjectSchema.parse(props);
+		const projectPath = pathTo.project(props.id);
+		await this.gitService.pull(projectPath);
+		await this.gitService.push(projectPath);
+	}
+	/**
+	* Deletes given Project
+	*
+	* Deletes the whole Project folder including the history, not only the config file.
+	* Throws in case a Project is only available locally and could be lost forever,
+	* or changes are not pushed to a remote yet.
+	*/
+	async delete(props) {
+		deleteProjectSchema.parse(props);
+		const hasRemoteOrigin = await this.gitService.remotes.hasOrigin(pathTo.project(props.id));
+		if (hasRemoteOrigin === false && props.force !== true) throw new RemoteOriginMissingError(props.id);
+		if (hasRemoteOrigin === true && props.force !== true) {
+			if ((await this.getChanges({ id: props.id })).ahead.length > 0) throw new SynchronizeLocalChangesError(props.id);
+		}
+		await Fs.remove(pathTo.project(props.id));
+	}
+	/**
+	* Lists outdated Projects that need to be upgraded
+	*/
+	async listOutdated() {
+		const projectReferences = await this.listReferences(objectTypeSchema.enum.project);
+		return (await Promise.all(projectReferences.map(async (reference) => {
+			const json = await this.jsonFileService.unsafeRead(pathTo.projectFile(reference.id));
+			const projectFile = outdatedProjectSchema.parse(json);
+			if (projectFile.coreVersion !== this.coreVersion) return projectFile;
+			return null;
+		}))).filter(isNotEmpty);
+	}
+	async list(props) {
+		if (props) listProjectsSchema.parse(props);
+		const offset = props?.offset || 0;
+		const limit = props?.limit || 15;
+		const projectReferences = await this.listReferences(objectTypeSchema.enum.project);
+		const partialProjectReferences = projectReferences.slice(offset, limit);
+		const projects = await this.returnResolved(partialProjectReferences.map((reference) => {
+			return this.read({ id: reference.id });
+		}));
+		return {
+			total: projectReferences.length,
+			limit,
+			offset,
+			list: projects
+		};
+	}
+	async count() {
+		return (await this.listReferences(objectTypeSchema.enum.project)).length;
+	}
+	/**
+	* Checks if given object is of type Project
+	*/
+	isProject(obj) {
+		return projectFileSchema.safeParse(obj).success;
+	}
+	/**
+	* Migrates an potentially outdated Project file to the current schema
+	*/
+	migrate(potentiallyOutdatedProjectFile) {
+		return projectFileSchema.parse(potentiallyOutdatedProjectFile);
+	}
+	/**
+	* Creates a Project from given ProjectFile
+	*/
+	async toProject(projectFile) {
+		const projectPath = pathTo.project(projectFile.id);
+		let remoteOriginUrl = null;
+		if (await this.gitService.remotes.hasOrigin(projectPath)) remoteOriginUrl = await this.gitService.remotes.getOriginUrl(projectPath);
+		const fullHistory = await this.gitService.log(pathTo.project(projectFile.id));
+		const history = await this.gitService.log(pathTo.project(projectFile.id), { filePath: pathTo.projectFile(projectFile.id) });
+		return {
+			...projectFile,
+			remoteOriginUrl,
+			history,
+			fullHistory
+		};
+	}
+	/**
+	* Creates the projects folder structure and makes sure to
+	* write empty .gitkeep files inside them to ensure they are
+	* committed
+	*/
+	async createFolderStructure(path) {
+		const folders$1 = Object.values(projectFolderSchema.enum);
+		await Promise.all(folders$1.map(async (folder) => {
+			await Fs.mkdirp(Path.join(path, folder));
+			await Fs.writeFile(Path.join(path, folder, ".gitkeep"), "");
+		}));
+	}
+	/**
+	* Writes the Projects main .gitignore file to disk
+	*
+	* @todo Add general things to ignore
+	* @see https://github.com/github/gitignore/tree/master/Global
+	*/
+	async createGitignore(path) {
+		await Fs.writeFile(Path.join(path, ".gitignore"), [
+			"# Ignore all hidden files and folders...",
+			".*",
+			"# ...but these",
+			"!/.gitignore",
+			"!/.gitattributes",
+			"!/**/.gitkeep",
+			"",
+			"# elek.io related ignores"
+		].join(Os.EOL));
+	}
+	async upgradeObjectFile(projectId, objectType, reference, collectionId) {
+		switch (objectType) {
+			case "asset": {
+				const assetFilePath = pathTo.assetFile(projectId, reference.id);
+				const prevAssetFile = await this.jsonFileService.unsafeRead(assetFilePath);
+				const migratedAssetFile = this.assetService.migrate(prevAssetFile);
+				await this.assetService.update({
+					projectId,
+					...migratedAssetFile
+				});
+				this.logService.info({
+					source: "core",
+					message: `Upgraded ${objectType} "${assetFilePath}"`,
+					meta: {
+						previous: prevAssetFile,
+						migrated: migratedAssetFile
+					}
+				});
+				return;
+			}
+			case "collection": {
+				const collectionFilePath = pathTo.collectionFile(projectId, reference.id);
+				const prevCollectionFile = await this.jsonFileService.unsafeRead(collectionFilePath);
+				const migratedCollectionFile = this.collectionService.migrate(prevCollectionFile);
+				await this.collectionService.update({
+					projectId,
+					...migratedCollectionFile
+				});
+				this.logService.info({
+					source: "core",
+					message: `Upgraded ${objectType} "${collectionFilePath}"`,
+					meta: {
+						previous: prevCollectionFile,
+						migrated: migratedCollectionFile
+					}
+				});
+				return;
+			}
+			case "entry": {
+				if (!collectionId) throw new RequiredParameterMissingError("collectionId");
+				const entryFilePath = pathTo.entryFile(projectId, collectionId, reference.id);
+				const prevEntryFile = await this.jsonFileService.unsafeRead(entryFilePath);
+				const migratedEntryFile = this.entryService.migrate(prevEntryFile);
+				await this.entryService.update({
+					projectId,
+					collectionId,
+					...migratedEntryFile
+				});
+				this.logService.info({
+					source: "core",
+					message: `Upgraded ${objectType} "${entryFilePath}"`,
+					meta: {
+						previous: prevEntryFile,
+						migrated: migratedEntryFile
+					}
+				});
+				return;
+			}
+			default: throw new Error(`Trying to upgrade unsupported object file of type "${objectType}"`);
+		}
+	}
+};
+
+//#endregion
+//#region src/service/UserService.ts
+/**
+* Service to handle the User that is currently working with Core
+*/
+var UserService = class {
+	logService;
+	jsonFileService;
+	constructor(logService, jsonFileService) {
+		this.logService = logService;
+		this.jsonFileService = jsonFileService;
+	}
+	/**
+	* Returns the User currently working with Core
+	*/
+	async get() {
+		try {
+			return await this.jsonFileService.read(pathTo.userFile, userFileSchema);
+		} catch {
+			this.logService.info({
+				source: "core",
+				message: "No User found"
+			});
+			return null;
+		}
+	}
+	/**
+	* Sets the User currently working with Core
+	*
+	* By doing so all git operations are done with the signature of this User
+	*/
+	async set(props) {
+		setUserSchema.parse(props);
+		const userFilePath = pathTo.userFile;
+		const userFile = { ...props };
+		if (userFile.userType === UserTypeSchema.enum.cloud) {}
+		await this.jsonFileService.update(userFile, userFilePath, userFileSchema);
+		this.logService.debug({
+			source: "core",
+			message: "Updated User"
+		});
+		return userFile;
+	}
+};
+
+//#endregion
+//#region src/index.node.ts
+/**
+* elek.io Core
+*
+* Provides access to all services Core is offering
+*/
+var ElekIoCore = class {
+	coreVersion;
+	options;
+	logService;
+	userService;
+	gitService;
+	jsonFileService;
+	assetService;
+	projectService;
+	collectionService;
+	entryService;
+	localApi;
+	constructor(props) {
+		this.coreVersion = package_default.version;
+		const parsedProps = constructorElekIoCoreSchema.parse(props);
+		this.options = Object.assign({}, {
+			log: { level: "info" },
+			file: { cache: true }
+		}, parsedProps);
+		this.logService = new LogService(this.options);
+		this.jsonFileService = new JsonFileService(this.options, this.logService);
+		this.userService = new UserService(this.logService, this.jsonFileService);
+		this.gitService = new GitService(this.options, this.logService, this.userService);
+		this.assetService = new AssetService(this.options, this.logService, this.jsonFileService, this.gitService);
+		this.collectionService = new CollectionService(this.options, this.logService, this.jsonFileService, this.gitService);
+		this.entryService = new EntryService(this.options, this.logService, this.jsonFileService, this.gitService, this.collectionService);
+		this.projectService = new ProjectService(this.coreVersion, this.options, this.logService, this.jsonFileService, this.userService, this.gitService, this.assetService, this.collectionService, this.entryService);
+		this.localApi = new LocalApi(this.logService, this.projectService, this.collectionService, this.entryService, this.assetService);
+		this.logService.info({
+			source: "core",
+			message: `Initializing elek.io Core ${this.coreVersion}`,
+			meta: { options: this.options }
+		});
+		Fs.mkdirpSync(pathTo.projects);
+		Fs.mkdirpSync(pathTo.tmp);
+		Fs.emptyDirSync(pathTo.tmp);
+	}
+	/**
+	* Exposes the logger
+	*/
+	get logger() {
+		return this.logService;
+	}
+	/**
+	* Utility / helper functions
+	*/
+	get util() {
+		return node_exports;
+	}
+	/**
+	* Exposes git functions
+	*/
+	get git() {
+		return this.gitService;
+	}
+	/**
+	* Getter and setter methods for the User currently working with Core
+	*/
+	get user() {
+		return this.userService;
+	}
+	/**
+	* CRUD methods to work with Projects
+	*/
+	get projects() {
+		return this.projectService;
+	}
+	/**
+	* CRUD methods to work with Assets
+	*/
+	get assets() {
+		return this.assetService;
+	}
+	/**
+	* CRUD methods to work with Collections
+	*/
+	get collections() {
+		return this.collectionService;
+	}
+	/**
+	* CRUD methods to work with Entries
+	*/
+	get entries() {
+		return this.entryService;
+	}
+	/**
+	* Allows starting and stopping a REST API
+	* to allow developers to read local Project data
+	*/
+	get api() {
+		return this.localApi;
+	}
+};
+
+//#endregion
+//#region src/cli/util.ts
+const core = new ElekIoCore({ log: { level: "info" } });
+function watchProjects() {
+	return chokidar.watch(core.util.pathTo.projects, {
+		ignoreInitial: true,
+		ignored: (path) => path.includes("/.git/")
+	});
+}
+
+//#endregion
+//#region src/index.cli.ts
+const program = new Command();
+program.name("elek").description("CLI for elek.io").version(package_default.version);
+program.command("generate:client").description("Generates a JS/TS API Client").argument("[outDir]", "The directory to generate the API Client in", "./.elek.io").argument("[language]", "The programming language of the generated API Client. Choose \"ts\" if you bundle it yourself in your TypeScript project, or \"js\" if you want a ready-to-use JavaScript API Client.", "ts").argument("[format]", "The output format of the generated API Client. Choose \"esm\" for ES Modules, or \"cjs\" for CommonJS. This option is only relevant if you choose \"js\" as the language.", "esm").argument("[target]", "The target environment of the generated API Client. Choose this depending on the JavaScript runtime you want to support. This option is only relevant if you choose \"js\" as the language.", "es2020").option("-w, --watch", "Watches for changes in your Projects and regenerates the API Client automatically.").action(async (outDir, language, format$1, target, options) => {
+	await generateApiClientAction(generateApiClientSchema.parse({
+		outDir,
+		language,
+		format: format$1,
+		target,
+		options
+	}));
+});
+program.command("api:start").description("Starts the local API").argument("[port]", "The port to run the local API on", "31310").action((port) => {
+	startApiAction(apiStartSchema.parse({ port }));
+});
+program.command("export").description("Exports all locally available Projects into a JSON file").argument("[outDir]", "The directory to write the JSON file to", "./.elek.io").argument("[projects]", "One or more Project IDs, separated by commas to export. If not provided, all Projects will be exported.", "all").option("-s, --separate", "Separates the exported Projects into individual files.").option("-w, --watch", "Watches for changes in your Projects and updates the JSON file automatically.").action(async (outDir, projects, options) => {
+	await exportAction(exportSchema.parse({
+		outDir,
+		projects,
+		options
+	}));
+});
+await program.parseAsync();
+
+//#endregion
+export {  };
+//# sourceMappingURL=index.cli.js.map