@elek-io/core 0.16.2 → 0.17.0

package/dist/node/index.node.mjs

@@ -19,11 +19,12 @@ import PQueue from "p-queue";
 import { createLogger, format, transports } from "winston";
 import DailyRotateFile from "winston-daily-rotate-file";
 import Semver from "semver";
+import { isDeepStrictEqual } from "node:util";
 
 //#region package.json
 var package_default = {
 	name: "@elek-io/core",
-	version: "0.16.2",
+	version: "0.17.0",
 	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",
@@ -218,11 +219,7 @@ const supportedLanguageSchema = z.enum([
 	"sv",
 	"zh"
 ]);
-const supportedIconSchema = z.enum([
-	"home",
-	"plus",
-	"foobar"
-]);
+const supportedIconSchema = z.enum(["home", "plus"]);
 const objectTypeSchema = z.enum([
 	"project",
 	"asset",
@@ -237,7 +234,7 @@ const logLevelSchema = z.enum([
 	"info",
 	"debug"
 ]);
-const versionSchema = z.string();
+const versionSchema = z.string().refine((version) => /^\d+\.\d+\.\d+(?:-[\w.]+)?(?:\+[\w.]+)?$/.test(version), "String must follow the Semantic Versioning format (https://semver.org/)");
 const uuidSchema = z.uuid();
 /**
 * A record that can be used to translate a string value into all supported languages
@@ -254,6 +251,41 @@ const translatableBooleanSchema = z.partialRecord(supportedLanguageSchema, z.boo
 function translatableArrayOf(schema) {
 	return z.partialRecord(supportedLanguageSchema, z.array(schema));
 }
+const reservedSlugs = new Set([
+	"index",
+	"new",
+	"create",
+	"update",
+	"delete",
+	"edit",
+	"list",
+	"count",
+	"api",
+	"admin",
+	"collection",
+	"collections",
+	"entry",
+	"entries",
+	"asset",
+	"assets",
+	"project",
+	"projects",
+	"null",
+	"undefined",
+	"true",
+	"false",
+	"constructor",
+	"__proto__",
+	"prototype",
+	"toString",
+	"valueOf",
+	"login",
+	"logout",
+	"auth",
+	"settings",
+	"config"
+]);
+const slugSchema = z.string().min(1).max(128).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).refine((slug) => !reservedSlugs.has(slug), { message: "This slug is reserved and cannot be used" });
 
 //#endregion
 //#region src/schema/fileSchema.ts
@@ -263,91 +295,36 @@ function translatableArrayOf(schema) {
 const baseFileSchema = z.object({
 	objectType: objectTypeSchema.readonly(),
 	id: uuidSchema.readonly(),
+	coreVersion: versionSchema.readonly(),
 	created: z.string().datetime().readonly(),
-	updated: z.string().datetime().nullable()
+	updated: z.string().datetime().nullable().readonly()
 });
 const fileReferenceSchema = z.object({
 	id: uuidSchema,
 	extension: z.string().optional()
 });
-
-//#endregion
-//#region src/schema/gitSchema.ts
 /**
-* Signature git uses to identify users
+* Schema for the collection index file (collections/index.json).
+* Maps collection UUIDs to their slug.plural values.
+* This is a local performance cache, not git-tracked.
 */
-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() });
+const collectionIndexSchema = z.record(uuidSchema, 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(),
+	name: z.string().trim().min(1),
+	description: z.string().trim().min(1),
 	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 assetSchema = assetFileSchema.extend({ absolutePath: z.string().readonly() }).openapi("Asset");
+const assetHistorySchema = z.object({
+	id: uuidSchema.readonly(),
+	projectId: uuidSchema.readonly()
+});
 const assetExportSchema = assetSchema.extend({});
 const createAssetSchema = assetFileSchema.pick({
 	name: true,
@@ -377,11 +354,15 @@ const deleteAssetSchema = assetFileSchema.pick({
 	id: true,
 	extension: true
 }).extend({ projectId: uuidSchema.readonly() });
+const migrateAssetSchema = z.looseObject(assetFileSchema.pick({
+	id: true,
+	coreVersion: true
+}).shape);
 const countAssetsSchema = z.object({ projectId: uuidSchema.readonly() });
 
 //#endregion
 //#region src/schema/valueSchema.ts
-const ValueTypeSchema = z.enum([
+const valueTypeSchema = z.enum([
 	"string",
 	"number",
 	"boolean",
@@ -396,20 +377,17 @@ const valueContentReferenceSchema = z.union([
 	valueContentReferenceToCollectionSchema,
 	valueContentReferenceToEntrySchema
 ]);
-const directValueBaseSchema = z.object({
-	objectType: z.literal(objectTypeSchema.enum.value).readonly(),
-	fieldDefinitionId: uuidSchema.readonly()
-});
+const directValueBaseSchema = z.object({ objectType: z.literal(objectTypeSchema.enum.value).readonly() });
 const directStringValueSchema = directValueBaseSchema.extend({
-	valueType: z.literal(ValueTypeSchema.enum.string).readonly(),
+	valueType: z.literal(valueTypeSchema.enum.string).readonly(),
 	content: translatableStringSchema
 });
 const directNumberValueSchema = directValueBaseSchema.extend({
-	valueType: z.literal(ValueTypeSchema.enum.number).readonly(),
+	valueType: z.literal(valueTypeSchema.enum.number).readonly(),
 	content: translatableNumberSchema
 });
 const directBooleanValueSchema = directValueBaseSchema.extend({
-	valueType: z.literal(ValueTypeSchema.enum.boolean).readonly(),
+	valueType: z.literal(valueTypeSchema.enum.boolean).readonly(),
 	content: translatableBooleanSchema
 });
 const directValueSchema = z.union([
@@ -419,8 +397,7 @@ const directValueSchema = z.union([
 ]);
 const referencedValueSchema = z.object({
 	objectType: z.literal(objectTypeSchema.enum.value).readonly(),
-	fieldDefinitionId: uuidSchema.readonly(),
-	valueType: z.literal(ValueTypeSchema.enum.reference).readonly(),
+	valueType: z.literal(valueTypeSchema.enum.reference).readonly(),
 	content: translatableArrayOf(valueContentReferenceSchema)
 });
 const valueSchema = z.union([directValueSchema, referencedValueSchema]);
@@ -435,19 +412,25 @@ const valueSchema = z.union([directValueSchema, referencedValueSchema]);
 //#region src/schema/entrySchema.ts
 const entryFileSchema = baseFileSchema.extend({
 	objectType: z.literal(objectTypeSchema.enum.entry).readonly(),
-	values: z.array(valueSchema)
+	values: z.record(slugSchema, valueSchema)
+});
+const entrySchema = entryFileSchema.openapi("Entry");
+const entryHistorySchema = z.object({
+	id: uuidSchema.readonly(),
+	projectId: uuidSchema.readonly(),
+	collectionId: uuidSchema.readonly()
 });
-const entrySchema = entryFileSchema.extend({ history: z.array(gitCommitSchema) }).openapi("Entry");
 const entryExportSchema = entrySchema.extend({});
 const createEntrySchema = entryFileSchema.omit({
 	id: true,
 	objectType: true,
+	coreVersion: true,
 	created: true,
 	updated: true
 }).extend({
 	projectId: uuidSchema.readonly(),
 	collectionId: uuidSchema.readonly(),
-	values: z.array(valueSchema)
+	values: z.record(slugSchema, valueSchema)
 });
 const readEntrySchema = z.object({
 	id: uuidSchema.readonly(),
@@ -457,6 +440,7 @@ const readEntrySchema = z.object({
 });
 const updateEntrySchema = entryFileSchema.omit({
 	objectType: true,
+	coreVersion: true,
 	created: true,
 	updated: true
 }).extend({
@@ -464,6 +448,10 @@ const updateEntrySchema = entryFileSchema.omit({
 	collectionId: uuidSchema.readonly()
 });
 const deleteEntrySchema = readEntrySchema.extend({});
+const migrateEntrySchema = z.looseObject(entryFileSchema.pick({
+	id: true,
+	coreVersion: true
+}).shape);
 const countEntriesSchema = z.object({
 	projectId: uuidSchema.readonly(),
 	collectionId: uuidSchema.readonly()
@@ -471,7 +459,7 @@ const countEntriesSchema = z.object({
 
 //#endregion
 //#region src/schema/fieldSchema.ts
-const FieldTypeSchema = z.enum([
+const fieldTypeSchema = z.enum([
 	"text",
 	"textarea",
 	"email",
@@ -487,64 +475,65 @@ const FieldTypeSchema = z.enum([
 	"asset",
 	"entry"
 ]);
-const FieldWidthSchema = z.enum([
+const fieldWidthSchema = z.enum([
 	"12",
 	"6",
 	"4",
 	"3"
 ]);
-const FieldDefinitionBaseSchema = z.object({
+const fieldDefinitionBaseSchema = z.object({
 	id: uuidSchema.readonly(),
+	slug: slugSchema,
 	label: translatableStringSchema,
 	description: translatableStringSchema.nullable(),
 	isRequired: z.boolean(),
 	isDisabled: z.boolean(),
 	isUnique: z.boolean(),
-	inputWidth: FieldWidthSchema
+	inputWidth: fieldWidthSchema
 });
 /**
 * String based Field definitions
 */
-const StringFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend({
-	valueType: z.literal(ValueTypeSchema.enum.string),
+const stringFieldDefinitionBaseSchema = fieldDefinitionBaseSchema.extend({
+	valueType: z.literal(valueTypeSchema.enum.string),
 	defaultValue: z.string().nullable()
 });
-const textFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-	fieldType: z.literal(FieldTypeSchema.enum.text),
+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),
+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),
+const emailFieldDefinitionSchema = stringFieldDefinitionBaseSchema.extend({
+	fieldType: z.literal(fieldTypeSchema.enum.email),
 	defaultValue: z.email().nullable()
 });
-const urlFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-	fieldType: z.literal(FieldTypeSchema.enum.url),
+const urlFieldDefinitionSchema = stringFieldDefinitionBaseSchema.extend({
+	fieldType: z.literal(fieldTypeSchema.enum.url),
 	defaultValue: z.url().nullable()
 });
-const ipv4FieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-	fieldType: z.literal(FieldTypeSchema.enum.ipv4),
+const ipv4FieldDefinitionSchema = stringFieldDefinitionBaseSchema.extend({
+	fieldType: z.literal(fieldTypeSchema.enum.ipv4),
 	defaultValue: z.ipv4().nullable()
 });
-const dateFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-	fieldType: z.literal(FieldTypeSchema.enum.date),
+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),
+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),
+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),
+const telephoneFieldDefinitionSchema = stringFieldDefinitionBaseSchema.extend({
+	fieldType: z.literal(fieldTypeSchema.enum.telephone),
 	defaultValue: z.e164().nullable()
 });
 const stringFieldDefinitionSchema = z.union([
@@ -561,16 +550,16 @@ const stringFieldDefinitionSchema = z.union([
 /**
 * Number based Field definitions
 */
-const NumberFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend({
-	valueType: z.literal(ValueTypeSchema.enum.number),
+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),
+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(),
@@ -579,24 +568,27 @@ const rangeFieldDefinitionSchema = NumberFieldDefinitionBaseSchema.extend({
 /**
 * Boolean based Field definitions
 */
-const BooleanFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend({
-	valueType: z.literal(ValueTypeSchema.enum.boolean),
+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) });
+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),
+const referenceFieldDefinitionBaseSchema = fieldDefinitionBaseSchema.extend({
+	valueType: z.literal(valueTypeSchema.enum.reference),
+	isUnique: z.literal(false)
+});
+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),
+const entryFieldDefinitionSchema = referenceFieldDefinitionBaseSchema.extend({
+	fieldType: z.literal(fieldTypeSchema.enum.entry),
 	ofCollections: z.array(uuidSchema),
 	min: z.number().nullable(),
 	max: z.number().nullable()
@@ -619,18 +611,23 @@ const collectionFileSchema = baseFileSchema.extend({
 		plural: translatableStringSchema
 	}),
 	slug: z.object({
-		singular: z.string(),
-		plural: z.string()
+		singular: slugSchema,
+		plural: slugSchema
 	}),
 	description: translatableStringSchema,
 	icon: supportedIconSchema,
 	fieldDefinitions: z.array(fieldDefinitionSchema)
 });
-const collectionSchema = collectionFileSchema.extend({ history: z.array(gitCommitSchema) }).openapi("Collection");
+const collectionSchema = collectionFileSchema.openapi("Collection");
+const collectionHistorySchema = z.object({
+	id: uuidSchema.readonly(),
+	projectId: uuidSchema.readonly()
+});
 const collectionExportSchema = collectionSchema.extend({ entries: z.array(entryExportSchema) });
 const createCollectionSchema = collectionFileSchema.omit({
 	id: true,
 	objectType: true,
+	coreVersion: true,
 	created: true,
 	updated: true
 }).extend({ projectId: uuidSchema.readonly() });
@@ -639,6 +636,11 @@ const readCollectionSchema = z.object({
 	projectId: uuidSchema.readonly(),
 	commitHash: z.string().optional().readonly()
 });
+const readBySlugCollectionSchema = z.object({
+	slug: slugSchema,
+	projectId: uuidSchema.readonly(),
+	commitHash: z.string().optional().readonly()
+});
 const updateCollectionSchema = collectionFileSchema.pick({
 	id: true,
 	name: true,
@@ -649,6 +651,14 @@ const updateCollectionSchema = collectionFileSchema.pick({
 }).extend({ projectId: uuidSchema.readonly() });
 const deleteCollectionSchema = readCollectionSchema.extend({});
 const countCollectionsSchema = z.object({ projectId: uuidSchema.readonly() });
+const migrateCollectionSchema = z.looseObject(collectionFileSchema.pick({
+	id: true,
+	coreVersion: true
+}).shape);
+const resolveCollectionIdSchema = z.object({
+	projectId: uuidSchema.readonly(),
+	idOrSlug: z.string()
+});
 
 //#endregion
 //#region src/schema/coreSchema.ts
@@ -665,15 +675,88 @@ const constructorElekIoCoreSchema = elekIoCoreOptionsSchema.partial({
 }).optional();
 
 //#endregion
-//#region src/schema/projectSchema.ts
-const projectStatusSchema = z.enum([
-	"foo",
-	"bar",
-	"todo"
+//#region src/schema/gitSchema.ts
+/**
+* Signature git uses to identify users
+*/
+const gitSignatureSchema = z.object({
+	name: z.string().regex(/^[^|]+$/, "Name must not contain pipe characters"),
+	email: z.string().email()
+});
+const gitMessageSchema = z.object({
+	method: z.enum([
+		"create",
+		"update",
+		"delete",
+		"upgrade",
+		"release"
+	]),
+	reference: z.object({
+		objectType: objectTypeSchema,
+		id: uuidSchema,
+		collectionId: uuidSchema.optional()
+	})
+});
+const gitTagMessageSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("release"),
+		version: versionSchema
+	}),
+	z.object({
+		type: z.literal("preview"),
+		version: versionSchema
+	}),
+	z.object({
+		type: z.literal("upgrade"),
+		coreVersion: versionSchema
+	})
 ]);
+const gitTagSchema = z.object({
+	id: uuidSchema,
+	message: gitTagMessageSchema,
+	author: gitSignatureSchema,
+	datetime: z.iso.datetime()
+});
+const gitCommitSchema = z.object({
+	hash: z.hash("sha1"),
+	message: gitMessageSchema,
+	author: gitSignatureSchema,
+	datetime: z.iso.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/projectSchema.ts
 const projectSettingsSchema = z.object({ language: z.object({
 	default: supportedLanguageSchema,
-	supported: z.array(supportedLanguageSchema)
+	supported: z.array(supportedLanguageSchema).refine((langs) => new Set(langs).size === langs.length, { message: "Supported languages must not contain duplicates" })
 }) });
 const projectFolderSchema = z.enum([
 	"assets",
@@ -684,22 +767,21 @@ const projectFolderSchema = z.enum([
 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" }),
+const projectSchema = projectFileSchema.extend({ remoteOriginUrl: z.string().nullable().openapi({ description: "URL of the remote Git repository" }) }).openapi("Project");
+const projectHistorySchema = z.object({ id: uuidSchema.readonly() });
+const projectHistoryResultSchema = z.object({
 	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({
+});
+const migrateProjectSchema = z.looseObject(projectFileSchema.pick({
 	id: true,
 	coreVersion: true
-}).loose();
+}).shape);
 const projectExportSchema = projectSchema.extend({
 	assets: z.array(assetExportSchema),
 	collections: z.array(collectionExportSchema)
@@ -724,13 +806,6 @@ const upgradeProjectSchema = z.object({
 	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() });
@@ -784,29 +859,29 @@ function getNumberValueContentSchemaFromFieldDefinition(fieldDefinition) {
 function getStringValueContentSchemaFromFieldDefinition(fieldDefinition) {
 	let schema = null;
 	switch (fieldDefinition.fieldType) {
-		case FieldTypeSchema.enum.email:
+		case fieldTypeSchema.enum.email:
 			schema = z.email();
 			break;
-		case FieldTypeSchema.enum.url:
+		case fieldTypeSchema.enum.url:
 			schema = z.url();
 			break;
-		case FieldTypeSchema.enum.ipv4:
+		case fieldTypeSchema.enum.ipv4:
 			schema = z.ipv4();
 			break;
-		case FieldTypeSchema.enum.date:
+		case fieldTypeSchema.enum.date:
 			schema = z.iso.date();
 			break;
-		case FieldTypeSchema.enum.time:
+		case fieldTypeSchema.enum.time:
 			schema = z.iso.time();
 			break;
-		case FieldTypeSchema.enum.datetime:
+		case fieldTypeSchema.enum.datetime:
 			schema = z.iso.datetime();
 			break;
-		case FieldTypeSchema.enum.telephone:
+		case fieldTypeSchema.enum.telephone:
 			schema = z.e164();
 			break;
-		case FieldTypeSchema.enum.text:
-		case FieldTypeSchema.enum.textarea:
+		case fieldTypeSchema.enum.text:
+		case fieldTypeSchema.enum.textarea:
 			schema = z.string().trim();
 			break;
 	}
@@ -822,10 +897,10 @@ function getStringValueContentSchemaFromFieldDefinition(fieldDefinition) {
 function getReferenceValueContentSchemaFromFieldDefinition(fieldDefinition) {
 	let schema;
 	switch (fieldDefinition.fieldType) {
-		case FieldTypeSchema.enum.asset:
+		case fieldTypeSchema.enum.asset:
 			schema = z.array(valueContentReferenceToAssetSchema);
 			break;
-		case FieldTypeSchema.enum.entry:
+		case fieldTypeSchema.enum.entry:
 			schema = z.array(valueContentReferenceToEntrySchema);
 			break;
 	}
@@ -851,47 +926,46 @@ function getTranslatableReferenceValueContentSchemaFromFieldDefinition(fieldDefi
 */
 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) });
+		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}"`);
 	}
 }
 /**
+* Builds a z.object shape from field definitions, keyed by slug
+*/
+function getValuesShapeFromFieldDefinitions(fieldDefinitions) {
+	const shape = {};
+	for (const fieldDef of fieldDefinitions) shape[fieldDef.slug] = getValueSchemaFromFieldDefinition(fieldDef);
+	return shape;
+}
+/**
 * Generates a schema for an Entry based on the given Field definitions and Values
 */
 function getEntrySchemaFromFieldDefinitions(fieldDefinitions) {
-	const valueSchemas = fieldDefinitions.map((fieldDefinition) => {
-		return getValueSchemaFromFieldDefinition(fieldDefinition);
-	});
 	return z.object({
 		...entrySchema.shape,
-		values: z.tuple(valueSchemas)
+		values: z.object(getValuesShapeFromFieldDefinitions(fieldDefinitions))
 	});
 }
 /**
 * 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)
+		values: z.object(getValuesShapeFromFieldDefinitions(fieldDefinitions))
 	});
 }
 /**
 * 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)
+		values: z.object(getValuesShapeFromFieldDefinitions(fieldDefinitions))
 	});
 }
 
@@ -907,7 +981,8 @@ const serviceTypeSchema = z.enum([
 	"Search",
 	"Collection",
 	"Entry",
-	"Value"
+	"Value",
+	"Release"
 ]);
 function paginatedListOf(schema) {
 	return z.object({
@@ -930,18 +1005,18 @@ const listGitTagsSchema = z.object({ path: z.string() });
 
 //#endregion
 //#region src/schema/userSchema.ts
-const UserTypeSchema = z.enum(["local", "cloud"]);
+const userTypeSchema = z.enum(["local", "cloud"]);
 const baseUserSchema = gitSignatureSchema.extend({
-	userType: UserTypeSchema,
+	userType: userTypeSchema,
 	language: supportedLanguageSchema,
 	localApi: z.object({
 		isEnabled: z.boolean(),
 		port: z.number()
 	})
 });
-const localUserSchema = baseUserSchema.extend({ userType: z.literal(UserTypeSchema.enum.local) });
+const localUserSchema = baseUserSchema.extend({ userType: z.literal(userTypeSchema.enum.local) });
 const cloudUserSchema = baseUserSchema.extend({
-	userType: z.literal(UserTypeSchema.enum.cloud),
+	userType: z.literal(userTypeSchema.enum.cloud),
 	id: uuidSchema
 });
 const userFileSchema = z.union([localUserSchema, cloudUserSchema]);
@@ -1015,6 +1090,97 @@ const logConsoleTransportSchema = logSchema.extend({
 	level: z.string()
 });
 
+//#endregion
+//#region src/schema/releaseSchema.ts
+const semverBumpSchema = z.enum([
+	"major",
+	"minor",
+	"patch"
+]);
+const fieldChangeTypeSchema = z.enum([
+	"added",
+	"deleted",
+	"valueTypeChanged",
+	"fieldTypeChanged",
+	"slugChanged",
+	"minMaxTightened",
+	"isRequiredToNotRequired",
+	"isUniqueToNotUnique",
+	"ofCollectionsChanged",
+	"isNotRequiredToRequired",
+	"isNotUniqueToUnique",
+	"labelChanged",
+	"descriptionChanged",
+	"defaultValueChanged",
+	"inputWidthChanged",
+	"isDisabledChanged",
+	"minMaxLoosened"
+]);
+const fieldChangeSchema = z.object({
+	collectionId: uuidSchema,
+	fieldId: uuidSchema,
+	fieldSlug: z.string(),
+	changeType: fieldChangeTypeSchema,
+	bump: semverBumpSchema
+});
+const collectionChangeTypeSchema = z.enum(["added", "deleted"]);
+const collectionChangeSchema = z.object({
+	collectionId: uuidSchema,
+	changeType: collectionChangeTypeSchema,
+	bump: semverBumpSchema
+});
+const projectChangeTypeSchema = z.enum([
+	"nameChanged",
+	"descriptionChanged",
+	"defaultLanguageChanged",
+	"supportedLanguageAdded",
+	"supportedLanguageRemoved"
+]);
+const projectChangeSchema = z.object({
+	changeType: projectChangeTypeSchema,
+	bump: semverBumpSchema
+});
+const assetChangeTypeSchema = z.enum([
+	"added",
+	"deleted",
+	"metadataChanged",
+	"binaryChanged"
+]);
+const assetChangeSchema = z.object({
+	assetId: uuidSchema,
+	changeType: assetChangeTypeSchema,
+	bump: semverBumpSchema
+});
+const entryChangeTypeSchema = z.enum([
+	"added",
+	"deleted",
+	"modified"
+]);
+const entryChangeSchema = z.object({
+	collectionId: uuidSchema,
+	entryId: uuidSchema,
+	changeType: entryChangeTypeSchema,
+	bump: semverBumpSchema
+});
+const releaseDiffSchema = z.object({
+	project: projectSchema,
+	bump: semverBumpSchema.nullable(),
+	currentVersion: versionSchema,
+	nextVersion: versionSchema.nullable(),
+	projectChanges: z.array(projectChangeSchema),
+	collectionChanges: z.array(collectionChangeSchema),
+	fieldChanges: z.array(fieldChangeSchema),
+	assetChanges: z.array(assetChangeSchema),
+	entryChanges: z.array(entryChangeSchema)
+});
+const prepareReleaseSchema = z.object({ projectId: uuidSchema.readonly() });
+const createReleaseSchema = z.object({ projectId: uuidSchema.readonly() });
+const createPreviewReleaseSchema = z.object({ projectId: uuidSchema.readonly() });
+const releaseResultSchema = z.object({
+	version: versionSchema,
+	diff: releaseDiffSchema
+});
+
 //#endregion
 //#region src/api/routes/content/v1/projects.ts
 const tags$3 = ["Content API v1"];
@@ -1136,29 +1302,36 @@ const router$5 = createRouter().openapi(createRoute({
 	return c.json(count, 200);
 }).openapi(createRoute({
 	summary: "Get one Collection",
-	description: "Retrieve a Collection by ID",
+	description: "Retrieve a Collection by UUID or slug",
 	method: "get",
-	path: "/{projectId}/collections/{collectionId}",
+	path: "/{projectId}/collections/{collectionIdOrSlug}",
 	tags: tags$2,
 	request: { params: z.object({
 		projectId: uuidSchema.openapi({ param: {
 			name: "projectId",
 			in: "path"
 		} }),
-		collectionId: uuidSchema.openapi({ param: {
-			name: "collectionId",
-			in: "path"
-		} })
+		collectionIdOrSlug: z.string().openapi({
+			param: {
+				name: "collectionIdOrSlug",
+				in: "path"
+			},
+			description: "Collection UUID or slug"
+		})
 	}) },
 	responses: { [200]: {
 		content: { "application/json": { schema: collectionSchema } },
 		description: "The requested Collection"
 	} }
 }), async (c) => {
-	const { projectId, collectionId } = c.req.valid("param");
+	const { projectId, collectionIdOrSlug } = c.req.valid("param");
+	const resolvedId = await c.var.collectionService.resolveCollectionId({
+		projectId,
+		idOrSlug: collectionIdOrSlug
+	});
 	const collection = await c.var.collectionService.read({
 		projectId,
-		id: collectionId
+		id: resolvedId
 	});
 	return c.json(collection, 200);
 });
@@ -1170,7 +1343,7 @@ 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",
+	path: "/{projectId}/collections/{collectionIdOrSlug}/entries",
 	tags: tags$1,
 	request: {
 		params: z.object({
@@ -1178,10 +1351,13 @@ const router$4 = createRouter().openapi(createRoute({
 				name: "projectId",
 				in: "path"
 			} }),
-			collectionId: uuidSchema.openapi({ param: {
-				name: "collectionId",
-				in: "path"
-			} })
+			collectionIdOrSlug: z.string().openapi({
+				param: {
+					name: "collectionIdOrSlug",
+					in: "path"
+				},
+				description: "Collection UUID or slug"
+			})
 		}),
 		query: z.object({
 			limit: z.string().pipe(z.coerce.number()).optional().openapi({
@@ -1199,8 +1375,12 @@ const router$4 = createRouter().openapi(createRoute({
 		description: "A list of Entries for the given Projects Collection"
 	} }
 }), async (c) => {
-	const { projectId, collectionId } = c.req.valid("param");
+	const { projectId, collectionIdOrSlug } = c.req.valid("param");
 	const { limit, offset } = c.req.valid("query");
+	const collectionId = await c.var.collectionService.resolveCollectionId({
+		projectId,
+		idOrSlug: collectionIdOrSlug
+	});
 	const entries = await c.var.entryService.list({
 		projectId,
 		collectionId,
@@ -1212,24 +1392,31 @@ const router$4 = createRouter().openapi(createRoute({
 	summary: "Count Entries",
 	description: "Counts all Entries of the given Projects Collection",
 	method: "get",
-	path: "/{projectId}/collections/{collectionId}/entries/count",
+	path: "/{projectId}/collections/{collectionIdOrSlug}/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"
-		} })
+		collectionIdOrSlug: z.string().openapi({
+			param: {
+				name: "collectionIdOrSlug",
+				in: "path"
+			},
+			description: "Collection UUID or slug"
+		})
 	}) },
 	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 { projectId, collectionIdOrSlug } = c.req.valid("param");
+	const collectionId = await c.var.collectionService.resolveCollectionId({
+		projectId,
+		idOrSlug: collectionIdOrSlug
+	});
 	const count = await c.var.entryService.count({
 		projectId,
 		collectionId
@@ -1239,17 +1426,20 @@ const router$4 = createRouter().openapi(createRoute({
 	summary: "Get one Entry",
 	description: "Retrieve an Entry by ID",
 	method: "get",
-	path: "/{projectId}/collections/{collectionId}/entries/{entryId}",
+	path: "/{projectId}/collections/{collectionIdOrSlug}/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"
-		} }),
+		collectionIdOrSlug: z.string().openapi({
+			param: {
+				name: "collectionIdOrSlug",
+				in: "path"
+			},
+			description: "Collection UUID or slug"
+		}),
 		entryId: uuidSchema.openapi({ param: {
 			name: "entryId",
 			in: "path"
@@ -1260,7 +1450,11 @@ const router$4 = createRouter().openapi(createRoute({
 		description: "The requested Entry"
 	} }
 }), async (c) => {
-	const { projectId, collectionId, entryId } = c.req.valid("param");
+	const { projectId, collectionIdOrSlug, entryId } = c.req.valid("param");
+	const collectionId = await c.var.collectionService.resolveCollectionId({
+		projectId,
+		idOrSlug: collectionIdOrSlug
+	});
 	const entry = await c.var.entryService.read({
 		projectId,
 		collectionId,
@@ -1527,6 +1721,9 @@ const pathTo = {
 	collectionFile: (projectId, id) => {
 		return Path.join(pathTo.collection(projectId, id), "collection.json");
 	},
+	collectionIndex: (projectId) => {
+		return Path.join(pathTo.collections(projectId), "index.json");
+	},
 	entries: (projectId, collectionId) => {
 		return Path.join(pathTo.collection(projectId, collectionId));
 	},
@@ -1749,6 +1946,38 @@ var AbstractCrudService = class {
 	}
 };
 
+//#endregion
+//#region src/service/migrations/applyMigrations.ts
+function applyMigrations(data, migrations, targetVersion) {
+	let current = structuredClone(data);
+	while (current["coreVersion"] !== targetVersion) {
+		const migration = migrations.find((m) => m.from === current["coreVersion"]);
+		if (!migration) {
+			current["coreVersion"] = targetVersion;
+			break;
+		}
+		current = migration.run(current);
+		current["coreVersion"] = migration.to;
+	}
+	return current;
+}
+
+//#endregion
+//#region src/service/migrations/assetMigrations.ts
+const assetMigrations = [];
+
+//#endregion
+//#region src/service/migrations/collectionMigrations.ts
+const collectionMigrations = [];
+
+//#endregion
+//#region src/service/migrations/entryMigrations.ts
+const entryMigrations = [];
+
+//#endregion
+//#region src/service/migrations/projectMigrations.ts
+const projectMigrations = [];
+
 //#endregion
 //#region src/util/shared.ts
 /**
@@ -1791,10 +2020,12 @@ function slug(string) {
 * Service that manages CRUD functionality for Asset files on disk
 */
 var AssetService = class extends AbstractCrudService {
+	coreVersion;
 	jsonFileService;
 	gitService;
-	constructor(options, logService, jsonFileService, gitService) {
+	constructor(coreVersion, options, logService, jsonFileService, gitService) {
 		super(serviceTypeSchema.enum.Asset, options, logService);
+		this.coreVersion = coreVersion;
 		this.jsonFileService = jsonFileService;
 		this.gitService = gitService;
 	}
@@ -1814,6 +2045,7 @@ var AssetService = class extends AbstractCrudService {
 			name: slug(props.name),
 			objectType: "asset",
 			id,
+			coreVersion: this.coreVersion,
 			created: datetime(),
 			updated: null,
 			extension: fileType.extension,
@@ -1858,6 +2090,13 @@ var AssetService = class extends AbstractCrudService {
 		}
 	}
 	/**
+	* Returns the commit history of an Asset
+	*/
+	async history(props) {
+		assetHistorySchema.parse(props);
+		return this.gitService.log(pathTo.project(props.projectId), { filePath: pathTo.assetFile(props.projectId, props.id) });
+	}
+	/**
 	* Copies an Asset to given file path on disk
 	*/
 	async save(props) {
@@ -1966,13 +2205,11 @@ var AssetService = class extends AbstractCrudService {
 	* @param projectId   The project's ID
 	* @param assetFile   The AssetFile to convert
 	*/
-	async toAsset(projectId, assetFile, commitHash) {
+	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
+			absolutePath: assetPath
 		};
 	}
 	/**
@@ -1995,7 +2232,8 @@ var AssetService = class extends AbstractCrudService {
 	* Migrates an potentially outdated Asset file to the current schema
 	*/
 	migrate(potentiallyOutdatedAssetFile) {
-		return assetFileSchema.parse(potentiallyOutdatedAssetFile);
+		const migrated = applyMigrations(migrateAssetSchema.parse(potentiallyOutdatedAssetFile), assetMigrations, this.coreVersion);
+		return assetFileSchema.parse(migrated);
 	}
 };
 
@@ -2005,29 +2243,59 @@ var AssetService = class extends AbstractCrudService {
 * Service that manages CRUD functionality for Collection files on disk
 */
 var CollectionService = class extends AbstractCrudService {
+	coreVersion;
 	jsonFileService;
 	gitService;
-	constructor(options, logService, jsonFileService, gitService) {
+	/** In-memory cache for collection indices, keyed by projectId */
+	cachedIndex = /* @__PURE__ */ new Map();
+	/** Promise deduplication for concurrent rebuilds, keyed by projectId */
+	rebuildPromise = /* @__PURE__ */ new Map();
+	constructor(coreVersion, options, logService, jsonFileService, gitService) {
 		super(serviceTypeSchema.enum.Collection, options, logService);
+		this.coreVersion = coreVersion;
 		this.jsonFileService = jsonFileService;
 		this.gitService = gitService;
 	}
 	/**
+	* Resolves a UUID-or-slug string to a collection UUID.
+	*
+	* If the input matches UUID format, verifies the folder exists on disk first.
+	* If the folder doesn't exist, falls back to slug lookup.
+	* Otherwise, looks up via the index.
+	*/
+	async resolveCollectionId(props) {
+		if (uuidSchema.safeParse(props.idOrSlug).success) {
+			const collectionPath = pathTo.collection(props.projectId, props.idOrSlug);
+			if (await Fs.pathExists(collectionPath)) return props.idOrSlug;
+		}
+		const index = await this.getIndex(props.projectId);
+		for (const [uuid, slugValue] of Object.entries(index)) if (slugValue === props.idOrSlug) return uuid;
+		this.cachedIndex.delete(props.projectId);
+		const freshIndex = await this.getIndex(props.projectId);
+		for (const [uuid, slugValue] of Object.entries(freshIndex)) if (slugValue === props.idOrSlug) return uuid;
+		throw new Error(`Collection not found: "${props.idOrSlug}" does not match any collection UUID or slug`);
+	}
+	/**
 	* Creates a new Collection
 	*/
 	async create(props) {
 		createCollectionSchema.parse(props);
+		this.validateFieldDefinitionSlugUniqueness(props.fieldDefinitions);
 		const id = uuid();
 		const projectPath = pathTo.project(props.projectId);
 		const collectionPath = pathTo.collection(props.projectId, id);
 		const collectionFilePath = pathTo.collectionFile(props.projectId, id);
+		const slugPlural = slug(props.slug.plural);
+		const index = await this.getIndex(props.projectId);
+		if (Object.values(index).includes(slugPlural)) throw new Error(`Collection slug "${slugPlural}" is already in use by another collection`);
 		const collectionFile = {
 			...props,
 			objectType: "collection",
 			id,
+			coreVersion: this.coreVersion,
 			slug: {
 				singular: slug(props.slug.singular),
-				plural: slug(props.slug.plural)
+				plural: slugPlural
 			},
 			created: datetime(),
 			updated: null
@@ -2042,7 +2310,9 @@ var CollectionService = class extends AbstractCrudService {
 				id
 			}
 		});
-		return this.toCollection(props.projectId, collectionFile);
+		index[id] = slugPlural;
+		await this.writeIndex(props.projectId, index);
+		return this.toCollection(collectionFile);
 	}
 	/**
 	* Returns a Collection by ID
@@ -2053,33 +2323,103 @@ var CollectionService = class extends AbstractCrudService {
 		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);
+			return this.toCollection(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);
+			return this.toCollection(collectionFile);
 		}
 	}
 	/**
+	* Reads a Collection by its slug
+	*/
+	async readBySlug(props) {
+		const id = await this.resolveCollectionId({
+			projectId: props.projectId,
+			idOrSlug: props.slug
+		});
+		return this.read({
+			projectId: props.projectId,
+			id,
+			commitHash: props.commitHash
+		});
+	}
+	/**
+	* Returns the commit history of a Collection
+	*/
+	async history(props) {
+		collectionHistorySchema.parse(props);
+		return this.gitService.log(pathTo.project(props.projectId), { filePath: pathTo.collectionFile(props.projectId, props.id) });
+	}
+	/**
 	* 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
+	* Handles fieldDefinition slug rename cascade and collection slug uniqueness.
 	*/
 	async update(props) {
 		updateCollectionSchema.parse(props);
+		this.validateFieldDefinitionSlugUniqueness(props.fieldDefinitions);
 		const projectPath = pathTo.project(props.projectId);
 		const collectionFilePath = pathTo.collectionFile(props.projectId, props.id);
+		const prevCollectionFile = await this.read(props);
 		const collectionFile = {
-			...await this.read(props),
+			...prevCollectionFile,
 			...props,
 			updated: datetime()
 		};
+		const oldFieldDefs = prevCollectionFile.fieldDefinitions;
+		const newFieldDefs = props.fieldDefinitions;
+		const slugRenames = [];
+		const oldByUuid = new Map(oldFieldDefs.map((fd) => [fd.id, fd]));
+		for (const newFd of newFieldDefs) {
+			const oldFd = oldByUuid.get(newFd.id);
+			if (oldFd && oldFd.slug !== newFd.slug) slugRenames.push({
+				oldSlug: oldFd.slug,
+				newSlug: newFd.slug
+			});
+		}
+		const filesToGitAdd = [collectionFilePath];
+		if (slugRenames.length > 0) {
+			const entriesPath = pathTo.entries(props.projectId, props.id);
+			if (await Fs.pathExists(entriesPath)) {
+				const entryFiles = (await Fs.readdir(entriesPath)).filter((f) => f.endsWith(".json") && f !== "collection.json");
+				for (const entryFileName of entryFiles) {
+					const entryFilePath = pathTo.entryFile(props.projectId, props.id, entryFileName.replace(".json", ""));
+					try {
+						const entryFile = await this.jsonFileService.read(entryFilePath, entryFileSchema);
+						let changed = false;
+						const newValues = { ...entryFile.values };
+						for (const { oldSlug, newSlug } of slugRenames) if (oldSlug in newValues) {
+							newValues[newSlug] = newValues[oldSlug];
+							delete newValues[oldSlug];
+							changed = true;
+						}
+						if (changed) {
+							const updatedEntryFile = {
+								...entryFile,
+								values: newValues
+							};
+							await this.jsonFileService.update(updatedEntryFile, entryFilePath, entryFileSchema);
+							filesToGitAdd.push(entryFilePath);
+						}
+					} catch (error) {
+						this.logService.warn({
+							source: "core",
+							message: `Failed to update entry "${entryFileName}" during slug rename cascade: ${error instanceof Error ? error.message : String(error)}`
+						});
+					}
+				}
+			}
+		}
+		const newSlugPlural = slug(props.slug.plural);
+		if (prevCollectionFile.slug.plural !== newSlugPlural) {
+			const index = await this.getIndex(props.projectId);
+			const existingUuid = Object.entries(index).find(([, s]) => s === newSlugPlural);
+			if (existingUuid && existingUuid[0] !== props.id) throw new Error(`Collection slug "${newSlugPlural}" is already in use by another collection`);
+			index[props.id] = newSlugPlural;
+			await this.writeIndex(props.projectId, index);
+		}
 		await this.jsonFileService.update(collectionFile, collectionFilePath, collectionFileSchema);
-		await this.gitService.add(projectPath, [collectionFilePath]);
+		await this.gitService.add(projectPath, filesToGitAdd);
 		await this.gitService.commit(projectPath, {
 			method: "update",
 			reference: {
@@ -2087,10 +2427,10 @@ var CollectionService = class extends AbstractCrudService {
 				id: collectionFile.id
 			}
 		});
-		return this.toCollection(props.projectId, collectionFile);
+		return this.toCollection(collectionFile);
 	}
 	/**
-	* Deletes given Collection (folder), including it's items
+	* Deletes given Collection (folder), including it's Entries
 	*
 	* The Fields that Collection used are not deleted.
 	*/
@@ -2107,6 +2447,9 @@ var CollectionService = class extends AbstractCrudService {
 				id: props.id
 			}
 		});
+		const index = await this.getIndex(props.projectId);
+		delete index[props.id];
+		await this.writeIndex(props.projectId, index);
 	}
 	async list(props) {
 		listCollectionsSchema.parse(props);
@@ -2141,7 +2484,8 @@ var CollectionService = class extends AbstractCrudService {
 	* Migrates an potentially outdated Collection file to the current schema
 	*/
 	migrate(potentiallyOutdatedCollectionFile) {
-		return collectionFileSchema.parse(potentiallyOutdatedCollectionFile);
+		const migrated = applyMigrations(migrateCollectionSchema.parse(potentiallyOutdatedCollectionFile), collectionMigrations, this.coreVersion);
+		return collectionFileSchema.parse(migrated);
 	}
 	/**
 	* Creates an Collection from given CollectionFile
@@ -2149,26 +2493,83 @@ var CollectionService = class extends AbstractCrudService {
 	* @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
-		};
+	toCollection(collectionFile) {
+		return { ...collectionFile };
 	}
-};
-
+	/**
+	* Gets the collection index, rebuilding from disk if not cached
+	*/
+	async getIndex(projectId) {
+		const cached = this.cachedIndex.get(projectId);
+		if (cached) return cached;
+		const pending = this.rebuildPromise.get(projectId);
+		if (pending) return pending;
+		const promise = this.rebuildIndex(projectId);
+		this.rebuildPromise.set(projectId, promise);
+		const result = await promise;
+		this.cachedIndex.set(projectId, result);
+		this.rebuildPromise.delete(projectId);
+		return result;
+	}
+	/**
+	* Writes the index file atomically and updates cache
+	*/
+	async writeIndex(projectId, index) {
+		const indexPath = pathTo.collectionIndex(projectId);
+		await Fs.writeFile(indexPath, JSON.stringify(index, null, 2), { encoding: "utf8" });
+		this.cachedIndex.set(projectId, index);
+	}
+	/**
+	* Rebuilds the index by scanning all collection folders
+	*/
+	async rebuildIndex(projectId) {
+		this.logService.info({
+			source: "core",
+			message: `Rebuilding Collection index for Project "${projectId}"`
+		});
+		const index = {};
+		const collectionFolders = await folders(pathTo.collections(projectId));
+		for (const folder of collectionFolders) {
+			if (!uuidSchema.safeParse(folder.name).success) continue;
+			try {
+				const collectionFilePath = pathTo.collectionFile(projectId, folder.name);
+				const collectionFile = await this.jsonFileService.read(collectionFilePath, collectionFileSchema);
+				index[collectionFile.id] = collectionFile.slug.plural;
+			} catch (error) {
+				this.logService.warn({
+					source: "core",
+					message: `Skipping collection folder "${folder.name}" during index rebuild: ${error instanceof Error ? error.message : String(error)}`
+				});
+			}
+		}
+		await this.writeIndex(projectId, index);
+		return index;
+	}
+	/**
+	* Validates that no two fieldDefinitions share the same slug
+	*/
+	validateFieldDefinitionSlugUniqueness(fieldDefinitions) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const fd of fieldDefinitions) {
+			if (seen.has(fd.slug)) throw new Error(`Duplicate fieldDefinition slug "${fd.slug}": each fieldDefinition within a collection must have a unique slug`);
+			seen.add(fd.slug);
+		}
+	}
+};
+
 //#endregion
 //#region src/service/EntryService.ts
 /**
 * Service that manages CRUD functionality for Entry files on disk
 */
 var EntryService = class extends AbstractCrudService {
+	coreVersion;
 	jsonFileService;
 	gitService;
 	collectionService;
-	constructor(options, logService, jsonFileService, gitService, collectionService) {
+	constructor(coreVersion, options, logService, jsonFileService, gitService, collectionService) {
 		super(serviceTypeSchema.enum.Entry, options, logService);
+		this.coreVersion = coreVersion;
 		this.jsonFileService = jsonFileService;
 		this.gitService = gitService;
 		this.collectionService = collectionService;
@@ -2188,11 +2589,12 @@ var EntryService = class extends AbstractCrudService {
 		const entryFile = {
 			objectType: "entry",
 			id,
+			coreVersion: this.coreVersion,
 			values: props.values,
 			created: datetime(),
 			updated: null
 		};
-		const entry = await this.toEntry(props.projectId, props.collectionId, entryFile);
+		const entry = this.toEntry(entryFile);
 		getCreateEntrySchemaFromFieldDefinitions(collection.fieldDefinitions).parse(props);
 		await this.jsonFileService.create(entryFile, entryFilePath, entryFileSchema);
 		await this.gitService.add(projectPath, [entryFilePath]);
@@ -2215,13 +2617,20 @@ var EntryService = class extends AbstractCrudService {
 		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);
+			return this.toEntry(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);
+			return this.toEntry(entryFile);
 		}
 	}
 	/**
+	* Returns the commit history of an Entry
+	*/
+	async history(props) {
+		entryHistorySchema.parse(props);
+		return this.gitService.log(pathTo.project(props.projectId), { filePath: pathTo.entryFile(props.projectId, props.collectionId, props.id) });
+	}
+	/**
 	* Updates an Entry of given Collection with new Values and shared Values
 	*/
 	async update(props) {
@@ -2241,7 +2650,7 @@ var EntryService = class extends AbstractCrudService {
 			values: props.values,
 			updated: datetime()
 		};
-		const entry = await this.toEntry(props.projectId, props.collectionId, entryFile);
+		const entry = this.toEntry(entryFile);
 		getUpdateEntrySchemaFromFieldDefinitions(collection.fieldDefinitions).parse(props);
 		await this.jsonFileService.update(entryFile, entryFilePath, entryFileSchema);
 		await this.gitService.add(projectPath, [entryFilePath]);
@@ -2307,17 +2716,14 @@ var EntryService = class extends AbstractCrudService {
 	* Migrates an potentially outdated Entry file to the current schema
 	*/
 	migrate(potentiallyOutdatedEntryFile) {
-		return entryFileSchema.parse(potentiallyOutdatedEntryFile);
+		const migrated = applyMigrations(migrateEntrySchema.parse(potentiallyOutdatedEntryFile), entryMigrations, this.coreVersion);
+		return entryFileSchema.parse(migrated);
 	}
 	/**
 	* 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
-		};
+	toEntry(entryFile) {
+		return { ...entryFile };
 	}
 };
 
@@ -2346,10 +2752,11 @@ var GitTagService = class extends AbstractCrudService {
 			id
 		];
 		if (props.hash) args = [...args, props.hash];
+		const fullMessage = `${this.serializeTagMessage(props.message)}\n\n${this.tagMessageToTrailers(props.message).join("\n")}`;
 		args = [
 			...args,
 			"-m",
-			props.message
+			fullMessage
 		];
 		await this.git(props.path, args);
 		return await this.read({
@@ -2408,27 +2815,33 @@ var GitTagService = class extends AbstractCrudService {
 	async list(props) {
 		listGitTagsSchema.parse(props);
 		let args = ["tag", "--list"];
+		const format = [
+			"%(refname:short)",
+			"%(trailers:key=Type,valueonly)",
+			"%(trailers:key=Version,valueonly)",
+			"%(trailers:key=Core-Version,valueonly)",
+			"%(*authorname)",
+			"%(*authoremail)",
+			"%(*authordate:iso-strict)"
+		].join("|");
 		args = [
 			...args,
 			"--sort=-*authordate",
-			"--format=%(refname:short)|%(subject)|%(*authorname)|%(*authoremail)|%(*authordate:iso-strict)"
+			`--format=${format}`
 		];
-		const gitTags = (await this.git(props.path, args)).stdout.split("\n").filter((line) => {
+		const gitTags = (await this.git(props.path, args)).stdout.replace(/\n\|/g, "|").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);
-			}
+			if (lineArray[5]?.startsWith("<") && lineArray[5]?.endsWith(">")) lineArray[5] = lineArray[5].slice(1, -1);
 			return {
 				id: lineArray[0],
-				message: lineArray[1],
+				message: this.parseTagTrailers(lineArray[1]?.trim(), lineArray[2]?.trim(), lineArray[3]?.trim()),
 				author: {
-					name: lineArray[2],
-					email: lineArray[3]
+					name: lineArray[4],
+					email: lineArray[5]
 				},
-				datetime: datetime(lineArray[4])
+				datetime: datetime(lineArray[6])
 			};
 		}).filter(this.isGitTag.bind(this));
 		return {
@@ -2451,6 +2864,43 @@ var GitTagService = class extends AbstractCrudService {
 		return (await this.list({ path: props.path })).total;
 	}
 	/**
+	* Serializes a GitTagMessage into a human-readable subject line
+	*/
+	serializeTagMessage(message) {
+		return `${message.type.charAt(0).toUpperCase() + message.type.slice(1)} ${message.type === "upgrade" ? message.coreVersion : message.version}`;
+	}
+	/**
+	* Converts a GitTagMessage into git trailer lines
+	*/
+	tagMessageToTrailers(message) {
+		const trailers = [`Type: ${message.type}`];
+		if (message.type === "upgrade") trailers.push(`Core-Version: ${message.coreVersion}`);
+		else trailers.push(`Version: ${message.version}`);
+		return trailers;
+	}
+	/**
+	* Parses git trailer values back into a GitTagMessage
+	*/
+	parseTagTrailers(type, version, coreVersion) {
+		switch (type) {
+			case "upgrade": return gitTagMessageSchema.parse({
+				type,
+				coreVersion
+			});
+			case "release":
+			case "preview": return gitTagMessageSchema.parse({
+				type,
+				version
+			});
+			default:
+				this.logService.warn({
+					source: "core",
+					message: `Tag with ID "${type}" has an invalid or missing Type trailer and will be ignored`
+				});
+				return null;
+		}
+	}
+	/**
 	* Type guard for GitTag
 	*
 	* @param obj The object to check
@@ -2740,9 +3190,16 @@ var GitService = class {
 		gitMessageSchema.parse(message);
 		const user = await this.userService.get();
 		if (!user) throw new NoCurrentUserError();
+		const subject = `${message.method.charAt(0).toUpperCase() + message.method.slice(1)} ${message.reference.objectType} ${message.reference.id}`;
+		const trailers = [
+			`Method: ${message.method}`,
+			`Object-Type: ${message.reference.objectType}`,
+			`Object-Id: ${message.reference.id}`
+		];
+		if (message.reference.collectionId) trailers.push(`Collection-Id: ${message.reference.collectionId}`);
 		const args = [
 			"commit",
-			`--message=${JSON.stringify(message)}`,
+			`--message=${`${subject}\n\n${trailers.join("\n")}`}`,
 			`--author=${user.name} <${user.email}>`
 		];
 		await this.git(path, args);
@@ -2762,33 +3219,52 @@ var GitService = class {
 		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"];
+		const format = [
+			"%H",
+			"%(trailers:key=Method,valueonly)",
+			"%(trailers:key=Object-Type,valueonly)",
+			"%(trailers:key=Object-Id,valueonly)",
+			"%(trailers:key=Collection-Id,valueonly)",
+			"%an",
+			"%ae",
+			"%aI",
+			"%D"
+		].join("|");
+		args = [...args, `--format=${format}`];
 		if (options?.filePath) args = [
 			...args,
 			"--",
 			options.filePath
 		];
-		const noEmptyLinesArr = (await this.git(path, args)).stdout.split("\n").filter((line) => {
+		const noEmptyLinesArr = (await this.git(path, args)).stdout.replace(/\n\|/g, "|").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 tagId = this.refNameToTagName(lineArray[8]?.trim() || "");
 			const tag = tagId ? await this.tags.read({
 				path,
 				id: tagId
 			}) : null;
+			const collectionId = lineArray[4]?.trim();
 			return {
 				hash: lineArray[0],
-				message: JSON.parse(lineArray[1] || ""),
+				message: {
+					method: lineArray[1]?.trim(),
+					reference: {
+						objectType: lineArray[2]?.trim(),
+						id: lineArray[3]?.trim(),
+						...collectionId ? { collectionId } : {}
+					}
+				},
 				author: {
-					name: lineArray[2],
-					email: lineArray[3]
+					name: lineArray[5],
+					email: lineArray[6]
 				},
-				datetime: datetime(lineArray[4]),
+				datetime: datetime(lineArray[7]),
 				tag
 			};
-		}))).filter(this.isGitCommit.bind(this));
+		}))).filter((obj) => this.isGitCommit(obj));
 	}
 	/**
 	* Retrieves the content of a file at a specific commit
@@ -2802,6 +3278,35 @@ var GitService = class {
 		};
 		return (await this.git(path, args, { processCallback: setEncoding })).stdout;
 	}
+	/**
+	* Lists directory entries at a specific commit
+	*
+	* Useful for discovering what files/folders existed at a past commit,
+	* e.g. to detect deleted collections when comparing branches.
+	*
+	* @see https://git-scm.com/docs/git-ls-tree
+	*
+	* @param path      Path to the repository
+	* @param treePath  Relative path within the repository to list
+	* @param commitRef Commit hash, branch name, or other git ref
+	*/
+	async listTreeAtCommit(path, treePath, commitRef) {
+		const args = [
+			"ls-tree",
+			"--name-only",
+			commitRef,
+			`${treePath.replace(`${path}${Path.sep}`, "").split("\\").join("/")}/`
+		];
+		try {
+			return (await this.git(path, args)).stdout.split("\n").map((line) => line.trim()).filter((line) => line !== "").map((entry) => {
+				const parts = entry.split("/");
+				return parts[parts.length - 1] || entry;
+			});
+		} catch (error) {
+			if (error instanceof GitError) return [];
+			throw error;
+		}
+	}
 	refNameToTagName(refName) {
 		const tagName = refName.replace("tag: ", "").trim();
 		if (tagName === "" || uuidSchema.safeParse(tagName).success === false) return null;
@@ -3170,7 +3675,6 @@ var ProjectService = class extends AbstractCrudService {
 			created: datetime(),
 			updated: null,
 			coreVersion: this.coreVersion,
-			status: "todo",
 			version: "0.0.1"
 		};
 		const projectPath = pathTo.project(id);
@@ -3224,11 +3728,23 @@ var ProjectService = class extends AbstractCrudService {
 			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))));
+			const projectFile = this.migrate(JSON.parse(await this.gitService.getFileContentAtCommit(pathTo.project(props.id), pathTo.projectFile(props.id), props.commitHash)));
 			return await this.toProject(projectFile);
 		}
 	}
 	/**
+	* Returns the commit history of a Project
+	*/
+	async history(props) {
+		projectHistorySchema.parse(props);
+		const projectPath = pathTo.project(props.id);
+		const fullHistory = await this.gitService.log(projectPath);
+		return {
+			history: await this.gitService.log(projectPath, { filePath: pathTo.projectFile(props.id) }),
+			fullHistory
+		};
+	}
+	/**
 	* Updates given Project
 	*/
 	async update(props) {
@@ -3261,7 +3777,7 @@ var ProjectService = class extends AbstractCrudService {
 		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));
+		const currentProjectFile = 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);
@@ -3298,7 +3814,10 @@ var ProjectService = class extends AbstractCrudService {
 			});
 			await this.gitService.tags.create({
 				path: projectPath,
-				message: `Upgraded Project to Core version ${migratedProjectFile.coreVersion}`
+				message: {
+					type: "upgrade",
+					coreVersion: migratedProjectFile.coreVersion
+				}
 			});
 			await this.gitService.branches.delete(projectPath, upgradeBranchName, true);
 			this.logService.info({
@@ -3404,7 +3923,7 @@ var ProjectService = class extends AbstractCrudService {
 		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;
+			if (projectFile.coreVersion !== this.coreVersion) return this.migrate(projectFile);
 			return null;
 		}))).filter(isNotEmpty);
 	}
@@ -3436,9 +3955,9 @@ var ProjectService = class extends AbstractCrudService {
 	/**
 	* Migrates an potentially outdated Project file to the current schema
 	*/
-	migrate(props) {
-		props.coreVersion = this.coreVersion;
-		return projectFileSchema.parse(props);
+	migrate(potentiallyOutdatedFile) {
+		const migrated = applyMigrations(migrateProjectSchema.parse(potentiallyOutdatedFile), projectMigrations, this.coreVersion);
+		return projectFileSchema.parse(migrated);
 	}
 	/**
 	* Creates a Project from given ProjectFile
@@ -3447,13 +3966,9 @@ var ProjectService = class extends AbstractCrudService {
 		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
+			remoteOriginUrl
 		};
 	}
 	/**
@@ -3483,7 +3998,8 @@ var ProjectService = class extends AbstractCrudService {
 			"!/.gitattributes",
 			"!/**/.gitkeep",
 			"",
-			"# elek.io related ignores"
+			"# elek.io related ignores",
+			"collections/index.json"
 		].join(Os.EOL));
 	}
 	async upgradeObjectFile(projectId, objectType, reference, collectionId) {
@@ -3549,6 +4065,665 @@ var ProjectService = class extends AbstractCrudService {
 	}
 };
 
+//#endregion
+//#region src/service/ReleaseService.ts
+/**
+* Service that manages Release functionality
+*
+* A release diffs the current `work` branch against the `production` branch
+* to determine what changed, computes a semver bump, and merges work into production.
+*/
+var ReleaseService = class extends AbstractCrudService {
+	gitService;
+	jsonFileService;
+	projectService;
+	constructor(options, logService, gitService, jsonFileService, projectService) {
+		super(serviceTypeSchema.enum.Release, options, logService);
+		this.gitService = gitService;
+		this.jsonFileService = jsonFileService;
+		this.projectService = projectService;
+	}
+	/**
+	* Prepares a release by diffing the current `work` branch against `production`.
+	*
+	* Returns a read-only summary of all changes and the computed next version.
+	* If there are no changes, the next version and bump will be null.
+	*/
+	async prepare(props) {
+		prepareReleaseSchema.parse(props);
+		const projectPath = pathTo.project(props.projectId);
+		const currentBranch = await this.gitService.branches.current(projectPath);
+		if (currentBranch !== projectBranchSchema.enum.work) throw new Error(`Not on work branch (currently on "${currentBranch}")`);
+		const project = await this.projectService.read({ id: props.projectId });
+		const currentVersion = project.version;
+		const productionRef = projectBranchSchema.enum.production;
+		const productionProject = await this.getProjectAtRef(props.projectId, projectPath, productionRef);
+		const projectDiff = this.diffProject(project, productionProject);
+		const currentCollections = await this.getCollectionsAtRef(props.projectId, projectPath, projectBranchSchema.enum.work);
+		const productionCollections = await this.getCollectionsAtRef(props.projectId, projectPath, productionRef);
+		const collectionDiff = this.diffCollections(currentCollections, productionCollections);
+		const currentAssets = await this.getAssetsAtRef(props.projectId, projectPath, projectBranchSchema.enum.work);
+		const productionAssets = await this.getAssetsAtRef(props.projectId, projectPath, productionRef);
+		const assetDiff = this.diffAssets(currentAssets, productionAssets);
+		const allCollectionIds = new Set([...currentCollections.map((c) => c.id), ...productionCollections.map((c) => c.id)]);
+		const entryDiff = await this.diffEntries(props.projectId, projectPath, allCollectionIds, productionRef);
+		let finalBump = null;
+		for (const bump of [
+			projectDiff.bump,
+			collectionDiff.bump,
+			assetDiff.bump,
+			entryDiff.bump
+		]) if (bump) finalBump = finalBump ? this.higherBump(finalBump, bump) : bump;
+		if (!finalBump) {
+			if (await this.hasCommitsBetween(projectPath, productionRef, projectBranchSchema.enum.work)) finalBump = "patch";
+		}
+		const nextVersion = finalBump ? Semver.inc(currentVersion, finalBump) : null;
+		return {
+			project,
+			bump: finalBump,
+			currentVersion,
+			nextVersion,
+			projectChanges: projectDiff.projectChanges,
+			collectionChanges: collectionDiff.collectionChanges,
+			fieldChanges: collectionDiff.fieldChanges,
+			assetChanges: assetDiff.assetChanges,
+			entryChanges: entryDiff.entryChanges
+		};
+	}
+	/**
+	* Creates a release by:
+	* 1. Recomputing the diff (stateless)
+	* 2. Merging `work` into `production`
+	* 3. Updating the project version on `production`
+	* 4. Tagging on `production`
+	* 5. Merging `production` back into `work` (fast-forward to sync the version commit)
+	* 6. Switching back to `work`
+	*/
+	async create(props) {
+		createReleaseSchema.parse(props);
+		const projectPath = pathTo.project(props.projectId);
+		const projectFilePath = pathTo.projectFile(props.projectId);
+		const diff = await this.prepare(props);
+		if (!diff.bump || !diff.nextVersion) throw new Error("Cannot create a release: no changes detected since the last full release");
+		const nextVersion = diff.nextVersion;
+		try {
+			await this.gitService.branches.switch(projectPath, projectBranchSchema.enum.production);
+			await this.gitService.merge(projectPath, projectBranchSchema.enum.work);
+			const updatedProjectFile = {
+				...diff.project,
+				version: nextVersion,
+				updated: datetime()
+			};
+			await this.jsonFileService.update(updatedProjectFile, projectFilePath, projectFileSchema);
+			await this.gitService.add(projectPath, [projectFilePath]);
+			await this.gitService.commit(projectPath, {
+				method: "release",
+				reference: {
+					objectType: "project",
+					id: props.projectId
+				}
+			});
+			await this.gitService.tags.create({
+				path: projectPath,
+				message: {
+					type: "release",
+					version: nextVersion
+				}
+			});
+			await this.gitService.branches.switch(projectPath, projectBranchSchema.enum.work);
+			await this.gitService.merge(projectPath, projectBranchSchema.enum.production);
+		} catch (error) {
+			await this.gitService.branches.switch(projectPath, projectBranchSchema.enum.work).catch(() => {});
+			throw error;
+		}
+		this.logService.info({
+			source: "core",
+			message: `Released version ${nextVersion} (${diff.bump} bump)`
+		});
+		return {
+			version: nextVersion,
+			diff
+		};
+	}
+	/**
+	* Creates a preview release by:
+	* 1. Recomputing the diff (stateless)
+	* 2. Computing the preview version (e.g. 1.1.0-preview.3)
+	* 3. Updating the project version on `work`
+	* 4. Tagging on `work` (no merge into production)
+	*
+	* Preview releases are snapshots of the current work state.
+	* They don't promote to production — only full releases do.
+	*/
+	async createPreview(props) {
+		createPreviewReleaseSchema.parse(props);
+		const projectPath = pathTo.project(props.projectId);
+		const projectFilePath = pathTo.projectFile(props.projectId);
+		const diff = await this.prepare(props);
+		if (!diff.bump || !diff.nextVersion) throw new Error("Cannot create a preview release: no changes detected since the last full release");
+		const previewNumber = await this.countPreviewsSinceLastRelease(projectPath, diff.nextVersion);
+		const previewVersion = `${diff.nextVersion}-preview.${previewNumber + 1}`;
+		try {
+			const updatedProjectFile = {
+				...diff.project,
+				version: previewVersion,
+				updated: datetime()
+			};
+			await this.jsonFileService.update(updatedProjectFile, projectFilePath, projectFileSchema);
+			await this.gitService.add(projectPath, [projectFilePath]);
+			await this.gitService.commit(projectPath, {
+				method: "release",
+				reference: {
+					objectType: "project",
+					id: props.projectId
+				}
+			});
+			await this.gitService.tags.create({
+				path: projectPath,
+				message: {
+					type: "preview",
+					version: previewVersion
+				}
+			});
+		} catch (error) {
+			await this.gitService.branches.switch(projectPath, projectBranchSchema.enum.work).catch(() => {});
+			throw error;
+		}
+		this.logService.info({
+			source: "core",
+			message: `Preview released version ${previewVersion} (${diff.bump} bump)`
+		});
+		return {
+			version: previewVersion,
+			diff
+		};
+	}
+	/**
+	* Reads the project file as it exists at a given git ref
+	*/
+	async getProjectAtRef(projectId, projectPath, ref) {
+		try {
+			const content = await this.gitService.getFileContentAtCommit(projectPath, pathTo.projectFile(projectId), ref);
+			return projectFileSchema.parse(JSON.parse(content));
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Reads asset metadata files as they exist at a given git ref
+	*/
+	async getAssetsAtRef(projectId, projectPath, ref) {
+		const assetsPath = pathTo.assets(projectId);
+		const fileNames = await this.gitService.listTreeAtCommit(projectPath, assetsPath, ref);
+		const assets = [];
+		for (const fileName of fileNames) {
+			if (!fileName.endsWith(".json")) continue;
+			const assetId = fileName.replace(".json", "");
+			const assetFilePath = pathTo.assetFile(projectId, assetId);
+			try {
+				const content = await this.gitService.getFileContentAtCommit(projectPath, assetFilePath, ref);
+				const assetFile = assetFileSchema.parse(JSON.parse(content));
+				assets.push(assetFile);
+			} catch {
+				this.logService.debug({
+					source: "core",
+					message: `Skipping asset "${fileName}" at ref "${ref}" during release diff`
+				});
+			}
+		}
+		return assets;
+	}
+	/**
+	* Reads entry files for a single collection as they exist at a given git ref
+	*/
+	async getEntriesAtRef(projectId, projectPath, collectionId, ref) {
+		const entriesPath = pathTo.entries(projectId, collectionId);
+		const fileNames = await this.gitService.listTreeAtCommit(projectPath, entriesPath, ref);
+		const entries = [];
+		for (const fileName of fileNames) {
+			if (!fileName.endsWith(".json") || fileName === "collection.json") continue;
+			const entryId = fileName.replace(".json", "");
+			const entryFilePath = pathTo.entryFile(projectId, collectionId, entryId);
+			try {
+				const content = await this.gitService.getFileContentAtCommit(projectPath, entryFilePath, ref);
+				const entryFile = entryFileSchema.parse(JSON.parse(content));
+				entries.push(entryFile);
+			} catch {
+				this.logService.debug({
+					source: "core",
+					message: `Skipping entry "${fileName}" in collection "${collectionId}" at ref "${ref}" during release diff`
+				});
+			}
+		}
+		return entries;
+	}
+	/**
+	* Reads collections as they exist at a given git ref (branch or commit)
+	*/
+	async getCollectionsAtRef(projectId, projectPath, ref) {
+		const collectionsPath = pathTo.collections(projectId);
+		const folderNames = await this.gitService.listTreeAtCommit(projectPath, collectionsPath, ref);
+		const collections = [];
+		for (const folderName of folderNames) {
+			const collectionFilePath = pathTo.collectionFile(projectId, folderName);
+			try {
+				const content = await this.gitService.getFileContentAtCommit(projectPath, collectionFilePath, ref);
+				const collectionFile = collectionFileSchema.parse(JSON.parse(content));
+				collections.push(collectionFile);
+			} catch {
+				this.logService.debug({
+					source: "core",
+					message: `Skipping folder "${folderName}" at ref "${ref}" during release diff`
+				});
+			}
+		}
+		return collections;
+	}
+	/**
+	* Checks if there are any commits between two refs
+	*/
+	async hasCommitsBetween(projectPath, from, to) {
+		try {
+			return (await this.gitService.log(projectPath, { between: {
+				from,
+				to
+			} })).length > 0;
+		} catch {
+			return true;
+		}
+	}
+	/**
+	* Diffs two sets of collections and returns all changes with the computed bump level.
+	*
+	* Always collects all changes so they can be displayed to the user.
+	*/
+	diffCollections(currentCollections, productionCollections) {
+		const collectionChanges = [];
+		const fieldChanges = [];
+		let highestBump = null;
+		const currentById = new Map(currentCollections.map((c) => [c.id, c]));
+		const productionById = new Map(productionCollections.map((c) => [c.id, c]));
+		for (const [id] of productionById) if (!currentById.has(id)) {
+			collectionChanges.push({
+				collectionId: id,
+				changeType: "deleted",
+				bump: "major"
+			});
+			highestBump = "major";
+		}
+		for (const [id] of currentById) if (!productionById.has(id)) {
+			collectionChanges.push({
+				collectionId: id,
+				changeType: "added",
+				bump: "minor"
+			});
+			highestBump = this.higherBump(highestBump, "minor");
+		}
+		for (const [id, currentCollection] of currentById) {
+			const productionCollection = productionById.get(id);
+			if (!productionCollection) continue;
+			const changes = this.diffFieldDefinitions(id, currentCollection.fieldDefinitions, productionCollection.fieldDefinitions);
+			fieldChanges.push(...changes);
+			for (const change of changes) highestBump = this.higherBump(highestBump, change.bump);
+		}
+		return {
+			bump: highestBump,
+			collectionChanges,
+			fieldChanges
+		};
+	}
+	/**
+	* Diffs the project file between current and production.
+	*
+	* Skips immutable/system-managed fields (id, objectType, created, updated, version, coreVersion).
+	*/
+	diffProject(current, production) {
+		const projectChanges = [];
+		if (!production) return {
+			bump: null,
+			projectChanges
+		};
+		let highestBump = null;
+		if (current.settings.language.default !== production.settings.language.default) {
+			projectChanges.push({
+				changeType: "defaultLanguageChanged",
+				bump: "major"
+			});
+			highestBump = "major";
+		}
+		const currentSupported = new Set(current.settings.language.supported);
+		const productionSupported = new Set(production.settings.language.supported);
+		for (const lang of productionSupported) if (!currentSupported.has(lang)) {
+			projectChanges.push({
+				changeType: "supportedLanguageRemoved",
+				bump: "major"
+			});
+			highestBump = "major";
+			break;
+		}
+		for (const lang of currentSupported) if (!productionSupported.has(lang)) {
+			projectChanges.push({
+				changeType: "supportedLanguageAdded",
+				bump: "minor"
+			});
+			highestBump = this.higherBump(highestBump, "minor");
+			break;
+		}
+		if (current.name !== production.name) {
+			projectChanges.push({
+				changeType: "nameChanged",
+				bump: "patch"
+			});
+			highestBump = this.higherBump(highestBump, "patch");
+		}
+		if (current.description !== production.description) {
+			projectChanges.push({
+				changeType: "descriptionChanged",
+				bump: "patch"
+			});
+			highestBump = this.higherBump(highestBump, "patch");
+		}
+		return {
+			bump: highestBump,
+			projectChanges
+		};
+	}
+	/**
+	* Diffs two sets of assets and returns all changes with the computed bump level.
+	*/
+	diffAssets(currentAssets, productionAssets) {
+		const assetChanges = [];
+		let highestBump = null;
+		const currentById = new Map(currentAssets.map((a) => [a.id, a]));
+		const productionById = new Map(productionAssets.map((a) => [a.id, a]));
+		for (const [id] of productionById) if (!currentById.has(id)) {
+			assetChanges.push({
+				assetId: id,
+				changeType: "deleted",
+				bump: "major"
+			});
+			highestBump = "major";
+		}
+		for (const [id] of currentById) if (!productionById.has(id)) {
+			assetChanges.push({
+				assetId: id,
+				changeType: "added",
+				bump: "minor"
+			});
+			highestBump = this.higherBump(highestBump, "minor");
+		}
+		for (const [id, current] of currentById) {
+			const production = productionById.get(id);
+			if (!production) continue;
+			if (current.extension !== production.extension || current.mimeType !== production.mimeType || current.size !== production.size) {
+				assetChanges.push({
+					assetId: id,
+					changeType: "binaryChanged",
+					bump: "patch"
+				});
+				highestBump = this.higherBump(highestBump, "patch");
+			}
+			if (current.name !== production.name || current.description !== production.description) {
+				assetChanges.push({
+					assetId: id,
+					changeType: "metadataChanged",
+					bump: "patch"
+				});
+				highestBump = this.higherBump(highestBump, "patch");
+			}
+		}
+		return {
+			bump: highestBump,
+			assetChanges
+		};
+	}
+	/**
+	* Diffs entries across all collections between current and production.
+	*/
+	async diffEntries(projectId, projectPath, allCollectionIds, productionRef) {
+		const entryChanges = [];
+		let highestBump = null;
+		for (const collectionId of allCollectionIds) {
+			const currentEntries = await this.getEntriesAtRef(projectId, projectPath, collectionId, projectBranchSchema.enum.work);
+			const productionEntries = await this.getEntriesAtRef(projectId, projectPath, collectionId, productionRef);
+			const currentById = new Map(currentEntries.map((e) => [e.id, e]));
+			const productionById = new Map(productionEntries.map((e) => [e.id, e]));
+			for (const [id] of productionById) if (!currentById.has(id)) {
+				entryChanges.push({
+					collectionId,
+					entryId: id,
+					changeType: "deleted",
+					bump: "major"
+				});
+				highestBump = "major";
+			}
+			for (const [id] of currentById) if (!productionById.has(id)) {
+				entryChanges.push({
+					collectionId,
+					entryId: id,
+					changeType: "added",
+					bump: "minor"
+				});
+				highestBump = this.higherBump(highestBump, "minor");
+			}
+			for (const [id, current] of currentById) {
+				const production = productionById.get(id);
+				if (!production) continue;
+				if (!isDeepStrictEqual(current.values, production.values)) {
+					entryChanges.push({
+						collectionId,
+						entryId: id,
+						changeType: "modified",
+						bump: "patch"
+					});
+					highestBump = this.higherBump(highestBump, "patch");
+				}
+			}
+		}
+		return {
+			bump: highestBump,
+			entryChanges
+		};
+	}
+	/**
+	* Diffs field definitions of a single collection.
+	*
+	* Matches fields by UUID and classifies each change.
+	* Always collects all changes so they can be displayed to the user.
+	*/
+	diffFieldDefinitions(collectionId, currentFields, productionFields) {
+		const changes = [];
+		const currentById = new Map(currentFields.map((f) => [f.id, f]));
+		const productionById = new Map(productionFields.map((f) => [f.id, f]));
+		for (const [id, field] of productionById) if (!currentById.has(id)) changes.push({
+			collectionId,
+			fieldId: id,
+			fieldSlug: field.slug,
+			changeType: "deleted",
+			bump: "major"
+		});
+		for (const [id, field] of currentById) if (!productionById.has(id)) changes.push({
+			collectionId,
+			fieldId: id,
+			fieldSlug: field.slug,
+			changeType: "added",
+			bump: "minor"
+		});
+		for (const [id, currentField] of currentById) {
+			const productionField = productionById.get(id);
+			if (!productionField) continue;
+			const fieldChanges = this.diffSingleField(collectionId, currentField, productionField);
+			changes.push(...fieldChanges);
+		}
+		return changes;
+	}
+	/**
+	* Compares two versions of the same field definition and returns all detected changes.
+	*
+	* Collects every change on the field so the full diff can be shown to the user.
+	*/
+	diffSingleField(collectionId, current, production) {
+		const changes = [];
+		const base = {
+			collectionId,
+			fieldId: current.id,
+			fieldSlug: current.slug
+		};
+		if (current.valueType !== production.valueType) changes.push({
+			...base,
+			changeType: "valueTypeChanged",
+			bump: "major"
+		});
+		if (current.fieldType !== production.fieldType) changes.push({
+			...base,
+			changeType: "fieldTypeChanged",
+			bump: "major"
+		});
+		if (current.slug !== production.slug) changes.push({
+			...base,
+			changeType: "slugChanged",
+			bump: "major"
+		});
+		if (this.isMinMaxTightened(current, production)) changes.push({
+			...base,
+			changeType: "minMaxTightened",
+			bump: "major"
+		});
+		if (production.isRequired === true && current.isRequired === false) changes.push({
+			...base,
+			changeType: "isRequiredToNotRequired",
+			bump: "major"
+		});
+		if (production.isUnique === true && current.isUnique === false) changes.push({
+			...base,
+			changeType: "isUniqueToNotUnique",
+			bump: "major"
+		});
+		if (current.fieldType === "entry" && production.fieldType === "entry") {
+			if (!isDeepStrictEqual([...current.ofCollections].sort(), [...production.ofCollections].sort())) changes.push({
+				...base,
+				changeType: "ofCollectionsChanged",
+				bump: "major"
+			});
+		}
+		if (production.isRequired === false && current.isRequired === true) changes.push({
+			...base,
+			changeType: "isNotRequiredToRequired",
+			bump: "minor"
+		});
+		if (production.isUnique === false && current.isUnique === true) changes.push({
+			...base,
+			changeType: "isNotUniqueToUnique",
+			bump: "minor"
+		});
+		if (this.isMinMaxLoosened(current, production)) changes.push({
+			...base,
+			changeType: "minMaxLoosened",
+			bump: "patch"
+		});
+		if (!isDeepStrictEqual(current.label, production.label)) changes.push({
+			...base,
+			changeType: "labelChanged",
+			bump: "patch"
+		});
+		if (!isDeepStrictEqual(current.description, production.description)) changes.push({
+			...base,
+			changeType: "descriptionChanged",
+			bump: "patch"
+		});
+		if ("defaultValue" in current && "defaultValue" in production && !isDeepStrictEqual(current.defaultValue, production.defaultValue)) changes.push({
+			...base,
+			changeType: "defaultValueChanged",
+			bump: "patch"
+		});
+		if (current.inputWidth !== production.inputWidth) changes.push({
+			...base,
+			changeType: "inputWidthChanged",
+			bump: "patch"
+		});
+		if (current.isDisabled !== production.isDisabled) changes.push({
+			...base,
+			changeType: "isDisabledChanged",
+			bump: "patch"
+		});
+		return changes;
+	}
+	/**
+	* Checks if min/max constraints have been tightened.
+	*
+	* Tightening means: new min > old min, or new max < old max.
+	* A null value means no constraint (unbounded).
+	*/
+	isMinMaxTightened(current, production) {
+		const currentMin = this.getMinMax(current, "min");
+		const productionMin = this.getMinMax(production, "min");
+		const currentMax = this.getMinMax(current, "max");
+		const productionMax = this.getMinMax(production, "max");
+		if (currentMin !== null && productionMin === null) return true;
+		if (currentMin !== null && productionMin !== null && currentMin > productionMin) return true;
+		if (currentMax !== null && productionMax === null) return true;
+		if (currentMax !== null && productionMax !== null && currentMax < productionMax) return true;
+		return false;
+	}
+	/**
+	* Checks if min/max constraints have been loosened.
+	*
+	* Loosening means: new min < old min, or new max > old max.
+	*/
+	isMinMaxLoosened(current, production) {
+		const currentMin = this.getMinMax(current, "min");
+		const productionMin = this.getMinMax(production, "min");
+		const currentMax = this.getMinMax(current, "max");
+		const productionMax = this.getMinMax(production, "max");
+		if (currentMin === null && productionMin !== null) return true;
+		if (currentMin !== null && productionMin !== null && currentMin < productionMin) return true;
+		if (currentMax === null && productionMax !== null) return true;
+		if (currentMax !== null && productionMax !== null && currentMax > productionMax) return true;
+		return false;
+	}
+	/**
+	* Safely extracts min or max from a field definition (not all types have it)
+	*/
+	getMinMax(field, prop) {
+		switch (field.fieldType) {
+			case "text":
+			case "textarea":
+			case "number":
+			case "range":
+			case "asset":
+			case "entry": return field[prop];
+			default: return null;
+		}
+	}
+	/**
+	* Counts existing preview tags for a given base version since the last full release.
+	*/
+	async countPreviewsSinceLastRelease(projectPath, baseVersion) {
+		const tags = await this.gitService.tags.list({ path: projectPath });
+		let count = 0;
+		for (const tag of tags.list) {
+			if (tag.message.type === "upgrade") continue;
+			if (tag.message.type === "release") break;
+			if (tag.message.type === "preview") {
+				if (tag.message.version.split("-")[0] === baseVersion) count++;
+			}
+		}
+		return count;
+	}
+	/**
+	* Returns the higher of two bumps (major > minor > patch)
+	*/
+	higherBump(a, b) {
+		const order = {
+			patch: 0,
+			minor: 1,
+			major: 2
+		};
+		if (a === null) return b;
+		return order[a] >= order[b] ? a : b;
+	}
+};
+
 //#endregion
 //#region src/service/UserService.ts
 /**
@@ -3584,7 +4759,7 @@ var UserService = class {
 		setUserSchema.parse(props);
 		const userFilePath = pathTo.userFile;
 		const userFile = { ...props };
-		if (userFile.userType === UserTypeSchema.enum.cloud) {}
+		if (userFile.userType === userTypeSchema.enum.cloud) {}
 		await this.jsonFileService.update(userFile, userFilePath, userFileSchema);
 		this.logService.debug({
 			source: "core",
@@ -3612,6 +4787,7 @@ var ElekIoCore = class {
 	projectService;
 	collectionService;
 	entryService;
+	releaseService;
 	localApi;
 	constructor(props) {
 		this.coreVersion = package_default.version;
@@ -3624,10 +4800,11 @@ var ElekIoCore = class {
 		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.assetService = new AssetService(this.coreVersion, this.options, this.logService, this.jsonFileService, this.gitService);
+		this.collectionService = new CollectionService(this.coreVersion, this.options, this.logService, this.jsonFileService, this.gitService);
+		this.entryService = new EntryService(this.coreVersion, 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.releaseService = new ReleaseService(this.options, this.logService, this.gitService, this.jsonFileService, this.projectService);
 		this.localApi = new LocalApi(this.logService, this.projectService, this.collectionService, this.entryService, this.assetService);
 		this.logService.info({
 			source: "core",
@@ -3687,6 +4864,12 @@ var ElekIoCore = class {
 		return this.entryService;
 	}
 	/**
+	* Prepare and create releases
+	*/
+	get releases() {
+		return this.releaseService;
+	}
+	/**
 	* Allows starting and stopping a REST API
 	* to allow developers to read local Project data
 	*/
@@ -3696,5 +4879,5 @@ var ElekIoCore = class {
 };
 
 //#endregion
-export { BooleanFieldDefinitionBaseSchema, FieldDefinitionBaseSchema, FieldTypeSchema, FieldWidthSchema, NumberFieldDefinitionBaseSchema, ReferenceFieldDefinitionBaseSchema, StringFieldDefinitionBaseSchema, UserTypeSchema, ValueTypeSchema, apiStartSchema, assetExportSchema, assetFieldDefinitionSchema, assetFileSchema, assetSchema, baseFileSchema, baseUserSchema, cloneProjectSchema, cloudUserSchema, collectionExportSchema, collectionFileSchema, collectionSchema, constructorElekIoCoreSchema, countAssetsSchema, countCollectionsSchema, countEntriesSchema, countGitTagsSchema, createAssetSchema, createCollectionSchema, createEntrySchema, createGitTagSchema, createProjectSchema, currentBranchProjectSchema, dateFieldDefinitionSchema, datetime, datetimeFieldDefinitionSchema, ElekIoCore as default, deleteAssetSchema, deleteCollectionSchema, deleteEntrySchema, deleteGitTagSchema, deleteProjectSchema, directBooleanValueSchema, directNumberValueSchema, directStringValueSchema, directValueBaseSchema, directValueSchema, elekIoCoreOptionsSchema, emailFieldDefinitionSchema, entryExportSchema, entryFieldDefinitionSchema, entryFileSchema, entrySchema, exportSchema, fieldDefinitionSchema, fileReferenceSchema, generateApiClientSchema, getChangesProjectSchema, getCreateEntrySchemaFromFieldDefinitions, getEntrySchemaFromFieldDefinitions, getRemoteOriginUrlProjectSchema, getTranslatableBooleanValueContentSchemaFromFieldDefinition, getTranslatableNumberValueContentSchemaFromFieldDefinition, getTranslatableReferenceValueContentSchemaFromFieldDefinition, getTranslatableStringValueContentSchemaFromFieldDefinition, getUpdateEntrySchemaFromFieldDefinitions, getValueSchemaFromFieldDefinition, gitCloneOptionsSchema, gitCommitSchema, gitInitOptionsSchema, gitLogOptionsSchema, gitMergeOptionsSchema, gitMessageSchema, gitSignatureSchema, gitSwitchOptionsSchema, gitTagSchema, ipv4FieldDefinitionSchema, listAssetsSchema, listBranchesProjectSchema, listCollectionsSchema, listEntriesSchema, listGitTagsSchema, listProjectsSchema, localUserSchema, logConsoleTransportSchema, logLevelSchema, logSchema, logSourceSchema, migrateProjectSchema, numberFieldDefinitionSchema, objectTypeSchema, paginatedListOf, projectBranchSchema, projectExportSchema, projectFileSchema, projectFolderSchema, projectSchema, projectSettingsSchema, projectStatusSchema, projectUpgradeSchema, rangeFieldDefinitionSchema, readAssetSchema, readCollectionSchema, readEntrySchema, readGitTagSchema, readProjectSchema, referencedValueSchema, saveAssetSchema, searchProjectSchema, serviceTypeSchema, setRemoteOriginUrlProjectSchema, setUserSchema, slug, stringFieldDefinitionSchema, supportedIconSchema, supportedLanguageSchema, switchBranchProjectSchema, synchronizeProjectSchema, telephoneFieldDefinitionSchema, textFieldDefinitionSchema, textareaFieldDefinitionSchema, timeFieldDefinitionSchema, toggleFieldDefinitionSchema, translatableArrayOf, translatableBooleanSchema, translatableNumberSchema, translatableStringSchema, updateAssetSchema, updateCollectionSchema, updateEntrySchema, updateProjectSchema, upgradeProjectSchema, urlFieldDefinitionSchema, userFileSchema, userSchema, uuid, uuidSchema, valueContentReferenceBase, valueContentReferenceSchema, valueContentReferenceToAssetSchema, valueContentReferenceToCollectionSchema, valueContentReferenceToEntrySchema, valueSchema, versionSchema };
+export { apiStartSchema, assetChangeSchema, assetChangeTypeSchema, assetExportSchema, assetFieldDefinitionSchema, assetFileSchema, assetHistorySchema, assetSchema, baseFileSchema, baseUserSchema, booleanFieldDefinitionBaseSchema, cloneProjectSchema, cloudUserSchema, collectionChangeSchema, collectionChangeTypeSchema, collectionExportSchema, collectionFileSchema, collectionHistorySchema, collectionIndexSchema, collectionSchema, constructorElekIoCoreSchema, countAssetsSchema, countCollectionsSchema, countEntriesSchema, countGitTagsSchema, createAssetSchema, createCollectionSchema, createEntrySchema, createGitTagSchema, createPreviewReleaseSchema, createProjectSchema, createReleaseSchema, currentBranchProjectSchema, dateFieldDefinitionSchema, datetime, datetimeFieldDefinitionSchema, ElekIoCore as default, deleteAssetSchema, deleteCollectionSchema, deleteEntrySchema, deleteGitTagSchema, deleteProjectSchema, directBooleanValueSchema, directNumberValueSchema, directStringValueSchema, directValueBaseSchema, directValueSchema, elekIoCoreOptionsSchema, emailFieldDefinitionSchema, entryChangeSchema, entryChangeTypeSchema, entryExportSchema, entryFieldDefinitionSchema, entryFileSchema, entryHistorySchema, entrySchema, exportSchema, fieldChangeSchema, fieldChangeTypeSchema, fieldDefinitionBaseSchema, fieldDefinitionSchema, fieldTypeSchema, fieldWidthSchema, fileReferenceSchema, generateApiClientSchema, getChangesProjectSchema, getCreateEntrySchemaFromFieldDefinitions, getEntrySchemaFromFieldDefinitions, getRemoteOriginUrlProjectSchema, getTranslatableBooleanValueContentSchemaFromFieldDefinition, getTranslatableNumberValueContentSchemaFromFieldDefinition, getTranslatableReferenceValueContentSchemaFromFieldDefinition, getTranslatableStringValueContentSchemaFromFieldDefinition, getUpdateEntrySchemaFromFieldDefinitions, getValueSchemaFromFieldDefinition, gitCloneOptionsSchema, gitCommitSchema, gitInitOptionsSchema, gitLogOptionsSchema, gitMergeOptionsSchema, gitMessageSchema, gitSignatureSchema, gitSwitchOptionsSchema, gitTagMessageSchema, gitTagSchema, ipv4FieldDefinitionSchema, listAssetsSchema, listBranchesProjectSchema, listCollectionsSchema, listEntriesSchema, listGitTagsSchema, listProjectsSchema, localUserSchema, logConsoleTransportSchema, logLevelSchema, logSchema, logSourceSchema, migrateAssetSchema, migrateCollectionSchema, migrateEntrySchema, migrateProjectSchema, numberFieldDefinitionBaseSchema, numberFieldDefinitionSchema, objectTypeSchema, paginatedListOf, prepareReleaseSchema, projectBranchSchema, projectChangeSchema, projectChangeTypeSchema, projectExportSchema, projectFileSchema, projectFolderSchema, projectHistoryResultSchema, projectHistorySchema, projectSchema, projectSettingsSchema, rangeFieldDefinitionSchema, readAssetSchema, readBySlugCollectionSchema, readCollectionSchema, readEntrySchema, readGitTagSchema, readProjectSchema, referenceFieldDefinitionBaseSchema, referencedValueSchema, releaseDiffSchema, releaseResultSchema, reservedSlugs, resolveCollectionIdSchema, saveAssetSchema, searchProjectSchema, semverBumpSchema, serviceTypeSchema, setRemoteOriginUrlProjectSchema, setUserSchema, slug, slugSchema, stringFieldDefinitionBaseSchema, stringFieldDefinitionSchema, supportedIconSchema, supportedLanguageSchema, switchBranchProjectSchema, synchronizeProjectSchema, telephoneFieldDefinitionSchema, textFieldDefinitionSchema, textareaFieldDefinitionSchema, timeFieldDefinitionSchema, toggleFieldDefinitionSchema, translatableArrayOf, translatableBooleanSchema, translatableNumberSchema, translatableStringSchema, updateAssetSchema, updateCollectionSchema, updateEntrySchema, updateProjectSchema, upgradeProjectSchema, urlFieldDefinitionSchema, userFileSchema, userSchema, userTypeSchema, uuid, uuidSchema, valueContentReferenceBase, valueContentReferenceSchema, valueContentReferenceToAssetSchema, valueContentReferenceToCollectionSchema, valueContentReferenceToEntrySchema, valueSchema, valueTypeSchema, versionSchema };
 //# sourceMappingURL=index.node.mjs.map