@elek-io/core 0.16.2 → 0.17.0

package/dist/astro/index.astro.mjs

@@ -18,6 +18,7 @@ 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 \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -39,7 +40,7 @@ var __exportAll = (all, no_symbols) => {
 //#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",
@@ -234,11 +235,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",
@@ -253,7 +250,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
@@ -270,6 +267,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
@@ -279,91 +311,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,
@@ -393,11 +370,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",
@@ -412,20 +393,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([
@@ -435,8 +413,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]);
@@ -451,19 +428,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(),
@@ -473,6 +456,7 @@ const readEntrySchema = z.object({
 });
 const updateEntrySchema = entryFileSchema.omit({
 	objectType: true,
+	coreVersion: true,
 	created: true,
 	updated: true
 }).extend({
@@ -480,6 +464,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()
@@ -487,7 +475,7 @@ const countEntriesSchema = z.object({
 
 //#endregion
 //#region src/schema/fieldSchema.ts
-const FieldTypeSchema = z.enum([
+const fieldTypeSchema = z.enum([
 	"text",
 	"textarea",
 	"email",
@@ -503,64 +491,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([
@@ -577,16 +566,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(),
@@ -595,24 +584,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()
@@ -635,18 +627,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() });
@@ -655,6 +652,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,
@@ -665,6 +667,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
@@ -681,15 +691,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",
@@ -700,22 +783,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)
@@ -740,13 +822,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() });
@@ -800,29 +875,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;
 	}
@@ -838,10 +913,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;
 	}
@@ -867,35 +942,37 @@ 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 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))
 	});
 }
 
@@ -911,7 +988,8 @@ const serviceTypeSchema = z.enum([
 	"Search",
 	"Collection",
 	"Entry",
-	"Value"
+	"Value",
+	"Release"
 ]);
 function paginatedListOf(schema) {
 	return z.object({
@@ -934,18 +1012,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]);
@@ -1019,6 +1097,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"];
@@ -1140,29 +1309,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);
 });
@@ -1174,7 +1350,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({
@@ -1182,10 +1358,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({
@@ -1203,8 +1382,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,
@@ -1216,24 +1399,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
@@ -1243,17 +1433,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"
@@ -1264,7 +1457,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,
@@ -1531,6 +1728,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));
 	},
@@ -1753,6 +1953,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
 /**
@@ -1795,10 +2027,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;
 	}
@@ -1818,6 +2052,7 @@ var AssetService = class extends AbstractCrudService {
 			name: slug(props.name),
 			objectType: "asset",
 			id,
+			coreVersion: this.coreVersion,
 			created: datetime(),
 			updated: null,
 			extension: fileType.extension,
@@ -1862,6 +2097,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) {
@@ -1970,13 +2212,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
 		};
 	}
 	/**
@@ -1999,7 +2239,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);
 	}
 };
 
@@ -2009,29 +2250,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
@@ -2046,7 +2317,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
@@ -2057,33 +2330,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: {
@@ -2091,10 +2434,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.
 	*/
@@ -2111,6 +2454,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);
@@ -2145,7 +2491,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
@@ -2153,26 +2500,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;
@@ -2192,11 +2596,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]);
@@ -2219,13 +2624,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) {
@@ -2245,7 +2657,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]);
@@ -2311,17 +2723,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 };
 	}
 };
 
@@ -2350,10 +2759,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({
@@ -2412,27 +2822,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 {
@@ -2455,6 +2871,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
@@ -2744,9 +3197,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);
@@ -2766,33 +3226,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
@@ -2806,6 +3285,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;
@@ -3174,7 +3682,6 @@ var ProjectService = class extends AbstractCrudService {
 			created: datetime(),
 			updated: null,
 			coreVersion: this.coreVersion,
-			status: "todo",
 			version: "0.0.1"
 		};
 		const projectPath = pathTo.project(id);
@@ -3228,11 +3735,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) {
@@ -3265,7 +3784,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);
@@ -3302,7 +3821,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({
@@ -3408,7 +3930,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);
 	}
@@ -3440,9 +3962,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
@@ -3451,13 +3973,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
 		};
 	}
 	/**
@@ -3487,7 +4005,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) {
@@ -3553,6 +4072,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
 /**
@@ -3588,7 +4766,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",
@@ -3616,6 +4794,7 @@ var ElekIoCore = class {
 	projectService;
 	collectionService;
 	entryService;
+	releaseService;
 	localApi;
 	constructor(props) {
 		this.coreVersion = package_default.version;
@@ -3628,10 +4807,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",
@@ -3691,6 +4871,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
 	*/
@@ -3705,23 +4891,23 @@ var ElekIoCore = class {
 * Generates a flat Zod object schema from collection field definitions
 * for use with Astro's `parseData` validation.
 *
-* Each key is the field definition ID (UUID) and each value schema
+* Each key is the field definition slug and each value schema
 * is the translatable content schema for that field type.
 */
 function buildEntryValuesSchema(fieldDefinitions) {
 	const shape = {};
 	for (const fieldDef of fieldDefinitions) switch (fieldDef.valueType) {
-		case ValueTypeSchema.enum.string:
-			shape[fieldDef.id] = getTranslatableStringValueContentSchemaFromFieldDefinition(fieldDef);
+		case valueTypeSchema.enum.string:
+			shape[fieldDef.slug] = getTranslatableStringValueContentSchemaFromFieldDefinition(fieldDef);
 			break;
-		case ValueTypeSchema.enum.number:
-			shape[fieldDef.id] = getTranslatableNumberValueContentSchemaFromFieldDefinition(fieldDef);
+		case valueTypeSchema.enum.number:
+			shape[fieldDef.slug] = getTranslatableNumberValueContentSchemaFromFieldDefinition(fieldDef);
 			break;
-		case ValueTypeSchema.enum.boolean:
-			shape[fieldDef.id] = getTranslatableBooleanValueContentSchemaFromFieldDefinition();
+		case valueTypeSchema.enum.boolean:
+			shape[fieldDef.slug] = getTranslatableBooleanValueContentSchemaFromFieldDefinition();
 			break;
-		case ValueTypeSchema.enum.reference:
-			shape[fieldDef.id] = getTranslatableReferenceValueContentSchemaFromFieldDefinition(fieldDef);
+		case valueTypeSchema.enum.reference:
+			shape[fieldDef.slug] = getTranslatableReferenceValueContentSchemaFromFieldDefinition(fieldDef);
 			break;
 	}
 	return z.object(shape);
@@ -3740,7 +4926,7 @@ function buildEntryValuesTypeString(fieldDefinitions) {
 		`export type Entry = {`,
 		fieldDefinitions.map((fieldDef) => {
 			const tsType = valueTypeToTsType(fieldDef.valueType);
-			return `  "${fieldDef.id}": Partial<Record<SupportedLanguage, ${tsType}>>`;
+			return `  "${fieldDef.slug}": Partial<Record<SupportedLanguage, ${tsType}>>`;
 		}).join(";\n") + ";",
 		`};`
 	].join("\n");
@@ -3758,13 +4944,13 @@ function valueTypeToTsType(valueType) {
 //#endregion
 //#region src/astro/transform.ts
 /**
-* Transforms an elek.io Entry's values array into a flat object
-* keyed by field definition ID. Each value's translatable content
+* Transforms an elek.io Entry's values record into a flat object
+* keyed by field definition slug. Each value's translatable content
 * is preserved as-is.
 */
 function transformEntryValues(values) {
 	const result = {};
-	for (const value of values) result[value.fieldDefinitionId] = value.content;
+	for (const [slug, value] of Object.entries(values)) result[slug] = value.content;
 	return result;
 }
 
@@ -3856,9 +5042,13 @@ function elekEntries(props) {
 	return {
 		name: "elek-entries",
 		createSchema: async () => {
+			const resolvedId = await core.collections.resolveCollectionId({
+				projectId: props.projectId,
+				idOrSlug: props.collectionIdOrSlug
+			});
 			const collection = await core.collections.read({
 				projectId: props.projectId,
-				id: props.collectionId
+				id: resolvedId
 			});
 			return {
 				schema: buildEntryValuesSchema(collection.fieldDefinitions),
@@ -3866,11 +5056,15 @@ function elekEntries(props) {
 			};
 		},
 		load: async (context) => {
-			context.logger.info(`Loading elek.io Entries of Collection "${props.collectionId}" and Project "${props.projectId}"`);
+			const resolvedCollectionId = await core.collections.resolveCollectionId({
+				projectId: props.projectId,
+				idOrSlug: props.collectionIdOrSlug
+			});
+			context.logger.info(`Loading elek.io Entries of Collection "${props.collectionIdOrSlug}" and Project "${props.projectId}"`);
 			context.store.clear();
 			const { list: entries, total } = await core.entries.list({
 				projectId: props.projectId,
-				collectionId: props.collectionId,
+				collectionId: resolvedCollectionId,
 				limit: 0
 			});
 			if (total === 0) context.logger.warn("No Entries found");