dineway 0.1.45 → 0.1.47

package/dist/byline-registry-CL8BxPPp.mjs

@@ -0,0 +1,287 @@
+import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
+import { t as withTransaction } from "./transaction-D0FOsb3X.mjs";
+import { i as RESERVED_BYLINE_FIELD_SLUGS, t as BYLINE_FIELD_TYPES } from "./types-DbZhHtqS.mjs";
+import { sql } from "kysely";
+import { ulid } from "ulidx";
+
+//#region src/schema/byline-registry.ts
+const VERSION_KEY = "byline_fields_version";
+const MAX_SELECT_OPTIONS = 200;
+const MAX_SLUG_LENGTH = 63;
+const MAX_LABEL_LENGTH = 200;
+const RESERVED_SET = new Set(RESERVED_BYLINE_FIELD_SLUGS);
+const TYPE_SET = new Set(BYLINE_FIELD_TYPES);
+var BylineSchemaError = class extends Error {
+	constructor(message, code, details) {
+		super(message);
+		this.code = code;
+		this.details = details;
+		this.name = "BylineSchemaError";
+	}
+};
+function mapBylineSchemaError(error) {
+	switch (error.code) {
+		case "FIELD_NOT_FOUND": return {
+			code: "NOT_FOUND",
+			message: error.message,
+			details: error.details
+		};
+		case "FIELD_EXISTS":
+		case "TRANSLATABLE_LOCKED":
+		case "REORDER_MISMATCH":
+		case "INVALID_SLUG":
+		case "RESERVED_SLUG":
+		case "INVALID_TYPE": return {
+			code: error.code,
+			message: error.message,
+			details: error.details
+		};
+		default: return {
+			code: "VALIDATION_ERROR",
+			message: error.message,
+			details: error.details
+		};
+	}
+}
+var BylineSchemaRegistry = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async listFields() {
+		return (await this.db.selectFrom("_dineway_byline_fields").selectAll().orderBy("sort_order", "asc").orderBy("created_at", "asc").execute()).map(mapFieldRow);
+	}
+	async getField(slug) {
+		const row = await this.db.selectFrom("_dineway_byline_fields").selectAll().where("slug", "=", slug).executeTakeFirst();
+		return row ? mapFieldRow(row) : null;
+	}
+	async getFieldById(id) {
+		const row = await this.db.selectFrom("_dineway_byline_fields").selectAll().where("id", "=", id).executeTakeFirst();
+		return row ? mapFieldRow(row) : null;
+	}
+	async createField(input) {
+		this.validateSlug(input.slug);
+		this.validateLabel(input.label);
+		this.validateType(input.type);
+		const validation = this.normaliseValidation(input.type, input.validation ?? null);
+		if (await this.getField(input.slug)) {
+			await this.markVersionClean();
+			throw new BylineSchemaError(`Byline field "${input.slug}" already exists`, "FIELD_EXISTS", { slug: input.slug });
+		}
+		const id = ulid();
+		const sortOrder = input.sortOrder ?? await this.nextSortOrder();
+		await this.markVersionDirty();
+		await withTransaction(this.db, async (trx) => {
+			await trx.insertInto("_dineway_byline_fields").values({
+				id,
+				slug: input.slug,
+				label: input.label,
+				type: input.type,
+				required: input.required ? 1 : 0,
+				translatable: input.translatable === false ? 0 : 1,
+				validation: validation ? JSON.stringify(validation) : null,
+				sort_order: sortOrder
+			}).execute();
+		});
+		await this.markVersionClean();
+		const created = await this.getFieldById(id);
+		if (!created) throw new BylineSchemaError("Failed to load created byline field", "FIELD_NOT_FOUND", { id });
+		return created;
+	}
+	async updateField(slug, input) {
+		const field = await this.getField(slug);
+		if (!field) {
+			await this.markVersionClean();
+			throw new BylineSchemaError(`Byline field "${slug}" not found`, "FIELD_NOT_FOUND", { slug });
+		}
+		const updates = {};
+		if (input.label !== void 0) {
+			this.validateLabel(input.label);
+			updates.label = input.label;
+		}
+		if (input.required !== void 0) updates.required = input.required ? 1 : 0;
+		if (input.validation !== void 0) {
+			const validation = this.normaliseValidation(field.type, input.validation);
+			updates.validation = validation ? JSON.stringify(validation) : null;
+		}
+		if (input.translatable !== void 0 && input.translatable !== field.translatable) {
+			const usage = await this.countFieldValues(field.id);
+			if (usage > 0) throw new BylineSchemaError(`Cannot change "translatable" on field "${slug}" while ${usage} value row(s) exist`, "TRANSLATABLE_LOCKED", {
+				slug,
+				valueCount: usage
+			});
+			updates.translatable = input.translatable ? 1 : 0;
+		}
+		if (input.sortOrder !== void 0) updates.sort_order = input.sortOrder;
+		if (Object.keys(updates).length === 0) {
+			await this.markVersionClean();
+			return field;
+		}
+		updates.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+		await this.markVersionDirty();
+		await withTransaction(this.db, async (trx) => {
+			await trx.updateTable("_dineway_byline_fields").set(updates).where("id", "=", field.id).execute();
+		});
+		await this.markVersionClean();
+		const updated = await this.getFieldById(field.id);
+		if (!updated) throw new BylineSchemaError("Failed to load updated byline field", "FIELD_NOT_FOUND", { slug });
+		return updated;
+	}
+	async deleteField(slug) {
+		const field = await this.getField(slug);
+		if (!field) {
+			await this.markVersionClean();
+			throw new BylineSchemaError(`Byline field "${slug}" not found`, "FIELD_NOT_FOUND", { slug });
+		}
+		await this.markVersionDirty();
+		await withTransaction(this.db, async (trx) => {
+			await trx.deleteFrom("_dineway_byline_field_values").where("field_id", "=", field.id).execute();
+			await trx.deleteFrom("_dineway_byline_field_group_values").where("field_id", "=", field.id).execute();
+			await trx.deleteFrom("_dineway_byline_fields").where("id", "=", field.id).execute();
+		});
+		await this.markVersionClean();
+	}
+	async reorderFields(slugs) {
+		if (new Set(slugs).size !== slugs.length) throw new BylineSchemaError("Reorder input contains duplicate slugs", "REORDER_MISMATCH", { slugs });
+		const registeredSlugs = (await this.listFields()).map((field) => field.slug).toSorted();
+		const inputSlugs = slugs.toSorted();
+		if (registeredSlugs.length !== inputSlugs.length || registeredSlugs.some((slug, index) => slug !== inputSlugs[index])) throw new BylineSchemaError("Reorder input does not match the registered byline field set", "REORDER_MISMATCH", {
+			registered: registeredSlugs,
+			input: inputSlugs
+		});
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		await this.markVersionDirty();
+		await withTransaction(this.db, async (trx) => {
+			for (let index = 0; index < slugs.length; index++) {
+				const slug = slugs[index];
+				if (slug === void 0) continue;
+				await trx.updateTable("_dineway_byline_fields").set({
+					sort_order: index,
+					updated_at: now
+				}).where("slug", "=", slug).execute();
+			}
+		});
+		await this.markVersionClean();
+	}
+	async getFieldUsage(slug) {
+		const field = await this.getField(slug);
+		if (!field) throw new BylineSchemaError(`Byline field "${slug}" not found`, "FIELD_NOT_FOUND", { slug });
+		const translatable = await this.db.selectFrom("_dineway_byline_field_values").select(({ fn }) => [fn.count("field_id").as("count")]).where("field_id", "=", field.id).executeTakeFirst();
+		const group = await this.db.selectFrom("_dineway_byline_field_group_values").select(({ fn }) => [fn.count("field_id").as("count")]).where("field_id", "=", field.id).executeTakeFirst();
+		const translatableValueCount = Number(translatable?.count ?? 0);
+		const groupValueCount = Number(group?.count ?? 0);
+		return {
+			translatableValueCount,
+			groupValueCount,
+			totalAffectedRows: translatableValueCount + groupValueCount
+		};
+	}
+	async getVersion() {
+		const row = await this.db.selectFrom("options").select("value").where("name", "=", VERSION_KEY).executeTakeFirst();
+		if (!row) return 0;
+		const parsed = Number.parseInt(row.value, 10);
+		return Number.isFinite(parsed) ? parsed : 0;
+	}
+	async markVersionDirty() {
+		await sql`
+			INSERT INTO options (name, value)
+			VALUES (${VERSION_KEY}, '1')
+			ON CONFLICT(name) DO UPDATE SET value = CASE
+				WHEN CAST(options.value AS INTEGER) % 2 = 0
+					THEN CAST(CAST(options.value AS INTEGER) + 1 AS TEXT)
+				ELSE options.value
+			END
+		`.execute(this.db);
+	}
+	async markVersionClean() {
+		await sql`
+			INSERT INTO options (name, value)
+			VALUES (${VERSION_KEY}, '2')
+			ON CONFLICT(name) DO UPDATE SET value = CASE
+				WHEN CAST(options.value AS INTEGER) % 2 = 0
+					THEN CAST(CAST(options.value AS INTEGER) + 2 AS TEXT)
+				ELSE CAST(CAST(options.value AS INTEGER) + 1 AS TEXT)
+			END
+		`.execute(this.db);
+	}
+	async nextSortOrder() {
+		const row = await this.db.selectFrom("_dineway_byline_fields").select(({ fn }) => [fn.max("sort_order").as("max")]).executeTakeFirst();
+		return row?.max == null ? 0 : row.max + 1;
+	}
+	async countFieldValues(fieldId) {
+		const translatable = await this.db.selectFrom("_dineway_byline_field_values").select(({ fn }) => [fn.count("field_id").as("count")]).where("field_id", "=", fieldId).executeTakeFirst();
+		const group = await this.db.selectFrom("_dineway_byline_field_group_values").select(({ fn }) => [fn.count("field_id").as("count")]).where("field_id", "=", fieldId).executeTakeFirst();
+		return Number(translatable?.count ?? 0) + Number(group?.count ?? 0);
+	}
+	validateSlug(slug) {
+		if (!slug || typeof slug !== "string") throw new BylineSchemaError("Byline field slug is required", "INVALID_SLUG", { slug });
+		if (slug.length > MAX_SLUG_LENGTH) throw new BylineSchemaError(`Byline field slug must be ${MAX_SLUG_LENGTH} characters or less`, "INVALID_SLUG", { slug });
+		try {
+			validateIdentifier(slug, "byline field slug");
+		} catch (error) {
+			throw new BylineSchemaError(error instanceof Error ? error.message : "Invalid byline field slug", "INVALID_SLUG", { slug });
+		}
+		if (RESERVED_SET.has(slug)) throw new BylineSchemaError(`Byline field slug "${slug}" is reserved`, "RESERVED_SLUG", { slug });
+	}
+	validateLabel(label) {
+		if (!label || typeof label !== "string") throw new BylineSchemaError("Byline field label is required", "INVALID_LABEL", { label });
+		if (label.length > MAX_LABEL_LENGTH) throw new BylineSchemaError(`Byline field label must be ${MAX_LABEL_LENGTH} characters or less`, "INVALID_LABEL", { length: label.length });
+	}
+	validateType(type) {
+		if (!TYPE_SET.has(type)) throw new BylineSchemaError(`Byline field type "${type}" is not supported`, "INVALID_TYPE", { type });
+	}
+	normaliseValidation(type, validation) {
+		if (type === "select") {
+			const options = validation?.options;
+			if (!Array.isArray(options) || options.length === 0) throw new BylineSchemaError("Byline field of type \"select\" requires validation.options", "INVALID_VALIDATION", { type });
+			if (options.length > MAX_SELECT_OPTIONS) throw new BylineSchemaError(`Byline field "select" cannot have more than ${MAX_SELECT_OPTIONS} options`, "INVALID_VALIDATION", { count: options.length });
+			const seen = /* @__PURE__ */ new Set();
+			for (const option of options) {
+				if (typeof option !== "string" || option.length === 0 || seen.has(option)) throw new BylineSchemaError("Byline field \"select\" options must be unique non-empty strings", "INVALID_VALIDATION", { option });
+				seen.add(option);
+			}
+			return { options };
+		}
+		return null;
+	}
+};
+function mapFieldRow(row) {
+	return {
+		id: row.id,
+		slug: row.slug,
+		label: row.label,
+		type: parseStoredFieldType(row.type),
+		required: row.required === 1,
+		translatable: row.translatable === 1,
+		validation: parseStoredValidation(row.validation),
+		sortOrder: row.sort_order,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function parseStoredFieldType(value) {
+	if (isBylineFieldType(value)) return value;
+	throw new BylineSchemaError(`Invalid stored byline field type "${value}"`, "INVALID_TYPE", { type: value });
+}
+function isBylineFieldType(value) {
+	return TYPE_SET.has(value);
+}
+function parseStoredValidation(raw) {
+	if (!raw) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw new BylineSchemaError("Invalid stored byline field validation JSON", "INVALID_VALIDATION");
+	}
+	if (!isBylineFieldValidation(parsed)) throw new BylineSchemaError("Invalid stored byline field validation", "INVALID_VALIDATION");
+	return parsed;
+}
+function isBylineFieldValidation(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	if (!("options" in value)) return true;
+	const options = value.options;
+	return Array.isArray(options) && options.every((option) => typeof option === "string");
+}
+
+//#endregion
+export { BylineSchemaRegistry as n, mapBylineSchemaError as r, BylineSchemaError as t };

package/dist/bylines-BgriNlW7.mjs

@@ -0,0 +1,165 @@
+import { a as __exportAll } from "./runner-DTfG5v0G.mjs";
+import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
+import { t as BylineRepository } from "./byline-CXQcMsBu.mjs";
+import { a as isMissingTableError, r as getDb } from "./loader-Y0QvC_QO.mjs";
+import { i as resolveLocaleChain } from "./resolve-DTuDyYKs.mjs";
+import { sql } from "kysely";
+
+//#region src/bylines/index.ts
+var bylines_exports = /* @__PURE__ */ __exportAll({
+	getByline: () => getByline,
+	getBylineBySlug: () => getBylineBySlug,
+	getBylinesForEntries: () => getBylinesForEntries,
+	invalidateBylineCache: () => invalidateBylineCache
+});
+function invalidateBylineCache() {}
+/**
+* Get a byline by ID.
+*
+* @example
+* ```ts
+* import { getByline } from "dineway";
+*
+* const byline = await getByline("01HXYZ...");
+* if (byline) {
+*   console.log(byline.displayName);
+* }
+* ```
+*/
+async function getByline(id) {
+	return new BylineRepository(await getDb()).findById(id);
+}
+/**
+* Get a byline by slug.
+*
+* @example
+* ```ts
+* import { getBylineBySlug } from "dineway";
+*
+* const byline = await getBylineBySlug("jane-doe");
+* if (byline) {
+*   console.log(byline.displayName); // "Jane Doe"
+* }
+* ```
+*/
+async function getBylineBySlug(slug, options) {
+	const repo = new BylineRepository(await getDb());
+	const chain = resolveLocaleChain(options?.locale);
+	if (chain.length === 0) return repo.findBySlug(slug);
+	for (const locale of chain) {
+		const byline = await repo.findBySlug(slug, { locale });
+		if (byline) return byline;
+	}
+	return null;
+}
+/**
+* Batch-fetch byline credits for multiple content entries in a single query.
+*
+* This is more efficient than calling getEntryBylines for each entry
+* when you need bylines for a list of entries (e.g., a blog index page).
+*
+* @param collection - The collection slug (e.g., "posts")
+* @param entries - Entry id + authorId pairs; authorId is already on the row
+* @returns Map from entry ID to array of byline credits
+*
+* @example
+* ```ts
+* import { getBylinesForEntries, getDinewayCollection } from "dineway";
+*
+* const { entries } = await getDinewayCollection("posts");
+* const refs = entries.map((e) => ({ id: e.data.id, authorId: e.data.authorId ?? null }));
+* const bylinesMap = await getBylinesForEntries("posts", refs);
+*
+* for (const entry of entries) {
+*   const bylines = bylinesMap.get(entry.data.id) ?? [];
+*   // render bylines
+* }
+* ```
+*/
+async function getBylinesForEntries(collection, entries) {
+	validateIdentifier(collection, "collection");
+	const result = /* @__PURE__ */ new Map();
+	for (const { id } of entries) result.set(id, []);
+	if (entries.length === 0) return result;
+	const repo = new BylineRepository(await getDb());
+	const hydrationTargets = [];
+	const buckets = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const key = entry.locale ?? null;
+		const bucket = buckets.get(key);
+		if (bucket) bucket.push(entry);
+		else buckets.set(key, [entry]);
+	}
+	const explicitByEntry = /* @__PURE__ */ new Map();
+	const entriesNeedingAuthorCheck = [];
+	for (const [locale, bucket] of buckets) {
+		const localeOpt = locale ? { locale } : void 0;
+		let bylinesMap;
+		try {
+			bylinesMap = await repo.getContentBylinesMany(collection, bucket.map((entry) => entry.id), {
+				...localeOpt,
+				skipHydration: true
+			});
+		} catch (error) {
+			if (isMissingTableError(error)) return result;
+			throw error;
+		}
+		for (const [id, list] of bylinesMap) {
+			explicitByEntry.set(id, list);
+			for (const credit of list) hydrationTargets.push(credit.byline);
+		}
+		for (const entry of bucket) {
+			const explicit = bylinesMap.get(entry.id);
+			if (explicit && explicit.length > 0) continue;
+			if (entry.authorId && !entry.primaryBylineId) entriesNeedingAuthorCheck.push(entry);
+		}
+	}
+	const fallbackByEntry = /* @__PURE__ */ new Map();
+	const authorBuckets = /* @__PURE__ */ new Map();
+	for (const entry of entriesNeedingAuthorCheck) {
+		const key = entry.locale ?? null;
+		const bucket = authorBuckets.get(key);
+		if (bucket) bucket.push(entry);
+		else authorBuckets.set(key, [entry]);
+	}
+	for (const [locale, bucket] of authorBuckets) {
+		const localeOpt = locale ? { locale } : void 0;
+		const authorIds = bucket.map((entry) => entry.authorId).filter((id) => id !== null);
+		const uniqueAuthorIds = [...new Set(authorIds)];
+		if (uniqueAuthorIds.length === 0) continue;
+		const authorBylineMap = await repo.findByUserIds(uniqueAuthorIds, {
+			...localeOpt,
+			skipHydration: true
+		});
+		for (const entry of bucket) {
+			if (!entry.authorId) continue;
+			const fallback = authorBylineMap.get(entry.authorId);
+			if (fallback) {
+				fallbackByEntry.set(entry.id, fallback);
+				hydrationTargets.push(fallback);
+			}
+		}
+	}
+	await repo.hydrateBylineCustomFields(hydrationTargets);
+	for (const { id } of entries) {
+		const explicit = explicitByEntry.get(id);
+		if (explicit && explicit.length > 0) {
+			result.set(id, explicit.map((c) => ({
+				...c,
+				source: "explicit"
+			})));
+			continue;
+		}
+		const fallback = fallbackByEntry.get(id);
+		if (fallback) result.set(id, [{
+			byline: fallback,
+			sortOrder: 0,
+			roleLabel: null,
+			source: "inferred"
+		}]);
+	}
+	return result;
+}
+
+//#endregion
+export { invalidateBylineCache as i, getByline as n, getBylineBySlug as r, bylines_exports as t };

package/dist/bylines-D2vqm1aZ.mjs

@@ -0,0 +1,163 @@
+import { n as getI18nConfig } from "./config-CVssduLe.mjs";
+import { t as DinewayValidationError } from "./types-Ck7-WoUD.mjs";
+import { t as BylineRepository } from "./byline-CXQcMsBu.mjs";
+
+//#region src/api/handlers/bylines.ts
+const norm = (value) => value ?? null;
+function bylineFixedFieldsMatch(existing, input, effectiveLocale) {
+	return existing.displayName === input.displayName && norm(existing.bio) === norm(input.bio) && norm(existing.avatarMediaId) === norm(input.avatarMediaId) && norm(existing.websiteUrl) === norm(input.websiteUrl) && norm(existing.userId) === norm(input.userId) && existing.isGuest === (input.isGuest ?? false) && existing.locale === effectiveLocale;
+}
+function existingCustomFieldsAreSubsetOf(existing, input) {
+	if (!input) return Object.keys(existing).length === 0;
+	for (const [slug, value] of Object.entries(existing)) {
+		if (!Object.hasOwn(input, slug)) return false;
+		if (input[slug] !== value) return false;
+	}
+	return true;
+}
+function rejectUnknownLocale(locale) {
+	if (!locale) return null;
+	const config = getI18nConfig();
+	if (!config) return null;
+	if (config.locales.includes(locale)) return null;
+	return {
+		success: false,
+		error: {
+			code: "VALIDATION_ERROR",
+			message: `Locale "${locale}" is not configured for this site`
+		}
+	};
+}
+async function handleBylineTranslations(db, id) {
+	try {
+		const repo = new BylineRepository(db);
+		if (!await repo.findById(id)) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Byline not found"
+			}
+		};
+		return {
+			success: true,
+			data: { items: await repo.listTranslations(id) }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "BYLINE_TRANSLATIONS_ERROR",
+				message: "Failed to list byline translations"
+			}
+		};
+	}
+}
+async function handleBylineCreate(db, input) {
+	try {
+		if (input.translationOf && !input.locale) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: "`locale` is required when `translationOf` is provided"
+			}
+		};
+		const localeErr = rejectUnknownLocale(input.locale);
+		if (localeErr) return localeErr;
+		const repo = new BylineRepository(db);
+		let sourceGroup;
+		if (input.translationOf) {
+			const source = await repo.findById(input.translationOf);
+			if (!source) return {
+				success: false,
+				error: {
+					code: "NOT_FOUND",
+					message: "Source byline for translation not found"
+				}
+			};
+			sourceGroup = source.translationGroup ?? source.id;
+		}
+		const effectiveLocale = input.locale ?? getI18nConfig()?.defaultLocale ?? "en";
+		if (sourceGroup) {
+			if ((await repo.findByTranslationGroup(sourceGroup)).some((byline) => byline.locale === effectiveLocale)) return {
+				success: false,
+				error: {
+					code: "CONFLICT",
+					message: `Translation already exists in locale "${effectiveLocale}" for this byline`
+				}
+			};
+		}
+		const existing = await repo.findBySlug(input.slug, { locale: effectiveLocale });
+		if (existing) {
+			const expectedTranslationGroup = sourceGroup ?? existing.id;
+			if (!!input.customFields && Object.keys(input.customFields).length > 0 && bylineFixedFieldsMatch(existing, input, effectiveLocale) && existing.translationGroup === expectedTranslationGroup && existingCustomFieldsAreSubsetOf(existing.customFields ?? {}, input.customFields)) {
+				const recovered = await repo.update(existing.id, { customFields: input.customFields });
+				if (recovered) return {
+					success: true,
+					data: recovered
+				};
+			}
+			return {
+				success: false,
+				error: {
+					code: "CONFLICT",
+					message: `Byline "${input.slug}" already exists${input.locale ? ` in locale "${input.locale}"` : ""}`
+				}
+			};
+		}
+		return {
+			success: true,
+			data: await repo.create(input)
+		};
+	} catch (error) {
+		if (error instanceof DinewayValidationError) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: error.message
+			}
+		};
+		console.error("[BYLINE_CREATE_ERROR]", error);
+		return {
+			success: false,
+			error: {
+				code: "BYLINE_CREATE_ERROR",
+				message: "Failed to create byline"
+			}
+		};
+	}
+}
+async function handleBylineUpdate(db, id, input) {
+	try {
+		const byline = await new BylineRepository(db).update(id, input);
+		if (!byline) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Byline not found"
+			}
+		};
+		return {
+			success: true,
+			data: byline
+		};
+	} catch (error) {
+		if (error instanceof DinewayValidationError) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: error.message
+			}
+		};
+		console.error("[BYLINE_UPDATE_ERROR]", error);
+		return {
+			success: false,
+			error: {
+				code: "BYLINE_UPDATE_ERROR",
+				message: "Failed to update byline"
+			}
+		};
+	}
+}
+
+//#endregion
+export { handleBylineTranslations as n, handleBylineUpdate as r, handleBylineCreate as t };

package/dist/{cache-DQyZ-QaB.mjs → cache-GRK71jOU.mjs}

@@ -1,5 +1,5 @@
-import { t as __exportAll } from "./chunk-ClPoSABd.mjs";
-import { i as matchPattern, n as interpolateDestination, t as compilePattern } from "./patterns-CiyXeDgr.mjs";
+import { a as __exportAll } from "./runner-DTfG5v0G.mjs";
+import { i as matchPattern, n as interpolateDestination, t as compilePattern } from "./patterns-D9iDO3j8.mjs";
 
 //#region src/redirects/cache.ts
 var cache_exports = /* @__PURE__ */ __exportAll({

package/dist/{chunks-D8KL0nCY.mjs → chunks-DgEw12Bc.mjs}

@@ -1,4 +1,4 @@
-import { t as __exportAll } from "./chunk-ClPoSABd.mjs";
+import { a as __exportAll } from "./runner-DTfG5v0G.mjs";
 
 //#region src/utils/chunks.ts
 var chunks_exports = /* @__PURE__ */ __exportAll({