@elek-io/core 0.15.3 → 0.16.1

package/dist/astro/index.astro.mjs

@@ -0,0 +1,3864 @@
+import Path from "node:path";
+import Fs from "fs-extra";
+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 "node:os";
+import { execFile } from "node:child_process";
+import mime from "mime";
+import slugify from "@sindresorhus/slugify";
+import { v4 } from "uuid";
+import { exec } 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 \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region package.json
+var package_default = {
+	name: "@elek-io/core",
+	version: "0.16.1",
+	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.mjs" },
+	files: [
+		"dist/node",
+		"dist/browser",
+		"dist/astro"
+	],
+	exports: {
+		".": {
+			"node": { "import": {
+				"types": "./dist/node/index.node.d.mts",
+				"default": "./dist/node/index.node.mjs"
+			} },
+			"import": {
+				"types": "./dist/browser/index.browser.d.ts",
+				"default": "./dist/browser/index.browser.js"
+			}
+		},
+		"./astro": { "import": {
+			"types": "./dist/astro/index.astro.d.mts",
+			"default": "./dist/astro/index.astro.mjs"
+		} }
+	},
+	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.11",
+		"@hono/zod-openapi": "1.2.2",
+		"@scalar/hono-api-reference": "0.10.0",
+		"@sindresorhus/slugify": "3.0.0",
+		"chokidar": "5.0.0",
+		"code-block-writer": "13.0.3",
+		"commander": "14.0.3",
+		"fs-extra": "11.3.4",
+		"hono": "4.12.5",
+		"mime": "4.1.0",
+		"p-queue": "9.1.0",
+		"semver": "7.7.4",
+		"tsdown": "0.21.0",
+		"uuid": "13.0.0",
+		"winston": "3.19.0",
+		"winston-daily-rotate-file": "5.0.0",
+		"zod": "4.3.6"
+	},
+	devDependencies: {
+		"@changesets/cli": "2.30.0",
+		"@eslint/js": "10.0.1",
+		"@faker-js/faker": "10.3.0",
+		"@tsconfig/node24": "24.0.4",
+		"@tsconfig/strictest": "2.0.8",
+		"@types/fs-extra": "11.0.4",
+		"@types/node": "24.12.0",
+		"@types/semver": "7.7.1",
+		"@vitest/coverage-v8": "4.0.18",
+		"astro": "5.18.0",
+		"eslint": "10.0.3",
+		"eslint-config-prettier": "10.1.8",
+		"globals": "17.4.0",
+		"jiti": "2.6.1",
+		"prettier": "3.8.1",
+		"typescript": "5.9.3",
+		"typescript-eslint": "8.56.1",
+		"vitest": "4.0.18"
+	},
+	peerDependencies: {
+		"astro": ">=5.0.0",
+		"dugite": "3.2.0"
+	},
+	peerDependenciesMeta: { "astro": { "optional": true } }
+};
+
+//#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 = c.get("requestId");
+	c.var.logService.info({
+		source: "core",
+		message: `Recieved API request "${method} ${url}" with requestId ${requestId}`
+	});
+	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} 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();
+/**
+* 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));
+/**
+* A record that can be used to translate a number value into all supported languages
+*/
+const translatableNumberSchema = z.partialRecord(supportedLanguageSchema, z.number());
+/**
+* A record that can be used to translate a boolean value into all supported languages
+*/
+const translatableBooleanSchema = z.partialRecord(supportedLanguageSchema, z.boolean());
+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),
+	description: z.string().trim().min(1),
+	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 migrateProjectSchema = projectFileSchema.pick({
+	id: true,
+	coreVersion: true
+}).loose();
+const projectExportSchema = projectSchema.extend({
+	assets: z.array(assetExportSchema),
+	collections: z.array(collectionExportSchema)
+});
+const createProjectSchema = projectSchema.pick({
+	name: true,
+	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
+});
+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
+/**
+* Dynamic zod schema generation
+*
+* Altough everything is already strictly typed, a type of string might not be an email or text of a certain length.
+* To validate this, we need to generate zod schemas based on Field definitions the user created.
+*/
+/**
+* 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);
+}
+/**
+* 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);
+	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({ watch: 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,
+	template: z$1.enum(["nested", "separate"]).default("nested"),
+	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);
+});
+
+//#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);
+});
+
+//#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);
+});
+
+//#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);
+});
+
+//#endregion
+//#region src/api/routes/content/v1/index.ts
+const router$2 = createRouter().route("/projects", router$6).route("/projects", router$5).route("/projects", router$4).route("/projects", router$3);
+
+//#endregion
+//#region src/api/routes/content/index.ts
+const router$1 = createRouter().route("/v1", router$2);
+
+//#endregion
+//#region src/api/routes/index.ts
+const router = createRouter().route("/content", router$1);
+
+//#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("/", router).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__ */ __exportAll({
+	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, options, logService) {
+		this.type = type;
+		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, projectId, collectionId) {
+		switch (type) {
+			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}"`);
+		}
+	}
+	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 = limit === 0 ? assetReferences.slice(offset) : assetReferences.slice(offset, 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 = limit === 0 ? collectionReferences.slice(offset) : collectionReferences.slice(offset, 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 = limit === 0 ? entryReferences.slice(offset) : entryReferences.slice(offset, 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) => {
+			return tag.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) {
+		const args = [
+			"add",
+			"--",
+			...files.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) {
+		await this.git(path, [
+			"check-ref-format",
+			"--allow-onelevel",
+			name
+		]);
+	}
+	/**
+	* 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 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.toString().trim() || result.gitResult.stdout.toString().trim()}"`);
+		return {
+			...result.gitResult,
+			stdout: result.gitResult.stdout.toString(),
+			stderr: result.gitResult.stderr.toString()
+		};
+	}
+};
+
+//#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 = this.cache.get(path);
+			return schema.parse(json);
+		}
+		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 splatArgs = props[Symbol.for("splat")];
+				const result = logConsoleTransportSchema.safeParse({
+					...splatArgs?.[0] ?? {},
+					timestamp: props["timestamp"],
+					level: props.level,
+					message: props.message
+				});
+				if (result.success) {
+					const { timestamp, level, source, message } = result.data;
+					return `${timestamp} [${source}] ${level}: ${message}`;
+				}
+				return `${String(props["timestamp"])} ${props.level}: ${String(props.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;
+	gitService;
+	assetService;
+	collectionService;
+	entryService;
+	constructor(coreVersion, options, logService, jsonFileService, gitService, assetService, collectionService, entryService) {
+		super(serviceTypeSchema.enum.Project, options, logService);
+		this.coreVersion = coreVersion;
+		this.jsonFileService = jsonFileService;
+		this.gitService = gitService;
+		this.assetService = assetService;
+		this.collectionService = collectionService;
+		this.entryService = entryService;
+	}
+	/**
+	* Creates a new Project
+	*/
+	async create(props) {
+		createProjectSchema.parse(props);
+		const id = uuid();
+		const projectFile = {
+			...props,
+			objectType: "project",
+			id,
+			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(migrateProjectSchema.parse(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 projectFile = {
+			...await this.read(props),
+			...props,
+			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 = migrateProjectSchema.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 = migrateProjectSchema.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 = limit === 0 ? projectReferences.slice(offset) : projectReferences.slice(offset, 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(props) {
+		props.coreVersion = this.coreVersion;
+		return projectFileSchema.parse(props);
+	}
+	/**
+	* 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 = Object.values(projectFolderSchema.enum);
+		await Promise.all(folders.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.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/astro/schema.ts
+/**
+* Generates a flat Zod object schema from collection field definitions
+* for use with Astro's `parseData` validation.
+*
+* Each key is the field definition ID (UUID) and each value schema
+* is the translatable content schema for that field type.
+*/
+function buildEntryValuesSchema(fieldDefinitions) {
+	const shape = {};
+	for (const fieldDef of fieldDefinitions) switch (fieldDef.valueType) {
+		case ValueTypeSchema.enum.string:
+			shape[fieldDef.id] = getTranslatableStringValueContentSchemaFromFieldDefinition(fieldDef);
+			break;
+		case ValueTypeSchema.enum.number:
+			shape[fieldDef.id] = getTranslatableNumberValueContentSchemaFromFieldDefinition(fieldDef);
+			break;
+		case ValueTypeSchema.enum.boolean:
+			shape[fieldDef.id] = getTranslatableBooleanValueContentSchemaFromFieldDefinition();
+			break;
+		case ValueTypeSchema.enum.reference:
+			shape[fieldDef.id] = getTranslatableReferenceValueContentSchemaFromFieldDefinition(fieldDef);
+			break;
+	}
+	return z.object(shape);
+}
+
+//#endregion
+//#region src/astro/transform.ts
+/**
+* Transforms an elek.io Entry's values array into a flat object
+* keyed by field definition ID. Each value's translatable content
+* is preserved as-is.
+*/
+function transformEntryValues(values) {
+	const result = {};
+	for (const value of values) result[value.fieldDefinitionId] = value.content;
+	return result;
+}
+
+//#endregion
+//#region src/index.astro.ts
+const core = new ElekIoCore({ log: { level: "info" } });
+/**
+* Astro content loader for elek.io Assets.
+*
+* Reads and saves Assets from a Project and exposes them through
+* Astro's content collection system.
+*
+* @example
+* ```ts
+* // src/content.config.ts
+* import { defineCollection } from 'astro:content';
+* import { elekAssets } from '@elek-io/core/astro';
+*
+* export const collections = {
+*   assets: defineCollection({
+*     loader: elekAssets({
+*       projectId: 'abc-123-...',
+*       outDir: './content/assets',
+*     }),
+*   });
+* };
+* ```
+*/
+function elekAssets(props) {
+	return {
+		name: "elek-assets",
+		schema: () => assetSchema,
+		load: async (context) => {
+			context.logger.info(`Loading elek.io Assets for Project "${props.projectId}", saving to "${props.outDir}"`);
+			context.store.clear();
+			const { list: assets, total } = await core.assets.list({
+				projectId: props.projectId,
+				limit: 0
+			});
+			if (total === 0) context.logger.warn("No Assets found");
+			else context.logger.info(`Found ${total} Assets`);
+			for (const asset of assets) {
+				const absoluteAssetFilePath = Path.resolve(Path.join(props.outDir, `${asset.id}.${asset.extension}`));
+				await Fs.ensureDir(Path.dirname(absoluteAssetFilePath));
+				await core.assets.save({
+					projectId: props.projectId,
+					id: asset.id,
+					filePath: absoluteAssetFilePath
+				});
+				const parsed = await context.parseData({
+					id: asset.id,
+					data: {
+						...asset,
+						absolutePath: absoluteAssetFilePath
+					}
+				});
+				context.store.set({
+					id: asset.id,
+					data: parsed
+				});
+			}
+			context.logger.info("Finished loading Assets");
+		}
+	};
+}
+/**
+* Astro content loader for elek.io Collection Entries.
+*
+* Reads all Entries from a Collection and exposes them through
+* Astro's content collection system.
+*
+* @example
+* ```ts
+* // src/content.config.ts
+* import { defineCollection } from 'astro:content';
+* import { elekEntries } from '@elek-io/core/astro';
+*
+* export const collections = {
+*   entries: defineCollection({
+*     loader: elekEntries({
+*       projectId: 'abc-123-...',
+*       collectionId: 'def-456-...',
+*     }),
+*   });
+* };
+* ```
+*/
+function elekEntries(props) {
+	return {
+		name: "elek-entries",
+		schema: async () => {
+			return buildEntryValuesSchema((await core.collections.read({
+				projectId: props.projectId,
+				id: props.collectionId
+			})).fieldDefinitions);
+		},
+		load: async (context) => {
+			context.logger.info(`Loading elek.io Entries of Collection "${props.collectionId}" and Project "${props.projectId}"`);
+			context.store.clear();
+			const { list: entries, total } = await core.entries.list({
+				projectId: props.projectId,
+				collectionId: props.collectionId,
+				limit: 0
+			});
+			if (total === 0) context.logger.warn("No Entries found");
+			else context.logger.info(`Found ${total} Entries`);
+			for (const entry of entries) {
+				const values = transformEntryValues(entry.values);
+				const parsed = await context.parseData({
+					id: entry.id,
+					data: values
+				});
+				context.store.set({
+					id: entry.id,
+					data: parsed
+				});
+			}
+			context.logger.info("Finished loading Entries");
+		}
+	};
+}
+
+//#endregion
+export { elekAssets, elekEntries };
+//# sourceMappingURL=index.astro.mjs.map