@jant/core 0.3.38 → 0.3.39

package/src/lib/resolve-config.ts

@@ -12,7 +12,16 @@
 import type { Bindings } from "../types/bindings.js";
 import type { AppConfig } from "../types/config.js";
 import { CONFIG_FIELDS } from "../types/config.js";
+import { getPublicAssetBasePath } from "./asset-path.js";
+import {
+  getAuthSecret,
+  getConfiguredSingleSiteUrl,
+  getConfiguredStorageDriver,
+  getEnvString,
+} from "./env.js";
 import { getPublicUrlForProvider, getMediaUrl } from "./image.js";
+import { normalizeTimeZone } from "./timezones.js";
+import { getSiteOrigin, getSitePathPrefix, normalizeSiteUrl } from "./url.js";
 
 /**
  * Resolve a single config value following priority rules.
@@ -29,6 +38,7 @@ function resolve(
 ): string {
   const field = CONFIG_FIELDS[key as keyof typeof CONFIG_FIELDS];
   if (!field) return "";
+  const envKeys = "envKeys" in field ? field.envKeys : undefined;
 
   // User-configurable: DB > ENV > Default
   if (!field.envOnly) {
@@ -37,8 +47,8 @@ function resolve(
   }
 
   // ENV > Default
-  const envValue = env[key as keyof Bindings];
-  if (envValue && typeof envValue === "string") return envValue;
+  const envValue = getEnvString(env, ...(envKeys ?? []));
+  if (envValue) return envValue;
 
   return field.defaultValue;
 }
@@ -54,13 +64,19 @@ function resolve(
 function resolveFallback(key: string, env: Bindings): string {
   const field = CONFIG_FIELDS[key as keyof typeof CONFIG_FIELDS];
   if (!field) return "";
+  const envKeys = "envKeys" in field ? field.envKeys : undefined;
 
-  const envValue = env[key as keyof Bindings];
-  if (envValue && typeof envValue === "string") return envValue;
+  const envValue = getEnvString(env, ...(envKeys ?? []));
+  if (envValue) return envValue;
 
   return field.defaultValue;
 }
 
+function parseConfigInt(value: string, fallback: number): number {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
 /**
  * Build a complete AppConfig from environment bindings and DB settings.
  *
@@ -79,11 +95,28 @@ function resolveFallback(key: string, env: Bindings): string {
 export function resolveConfig(
   env: Bindings,
   allSettings: Record<string, string>,
+  options?: { siteUrl?: string },
 ): AppConfig {
-  const storageDriver = env.STORAGE_DRIVER || "r2";
-  const r2PublicUrl = env.R2_PUBLIC_URL || "";
-  const s3PublicUrl = env.S3_PUBLIC_URL || "";
-  const imageTransformUrl = env.IMAGE_TRANSFORM_URL || "";
+  const pageSize = parseConfigInt(resolve("PAGE_SIZE", allSettings, env), 50);
+  const searchPageSize = parseConfigInt(
+    resolve("SEARCH_PAGE_SIZE", allSettings, env),
+    pageSize,
+  );
+  const archivePageSize = parseConfigInt(
+    resolve("ARCHIVE_PAGE_SIZE", allSettings, env),
+    pageSize,
+  );
+  const siteUrl = normalizeSiteUrl(
+    options?.siteUrl ?? getConfiguredSingleSiteUrl(env),
+  );
+  const siteOrigin = getSiteOrigin(siteUrl);
+  const sitePathPrefix = getSitePathPrefix(siteUrl);
+  const storageDriver = getConfiguredStorageDriver(env);
+  const r2PublicUrl = getEnvString(env, "R2_PUBLIC_URL") || "";
+  const s3PublicUrl = getEnvString(env, "S3_PUBLIC_URL") || "";
+  const localPublicUrl = getEnvString(env, "LOCAL_PUBLIC_URL") || "";
+  const imageTransformUrl = getEnvString(env, "IMAGE_TRANSFORM_URL") || "";
+  const demoMode = getEnvString(env, "DEMO_MODE") === "true";
 
   // Resolve avatar URL from storage key
   const siteAvatar = allSettings["SITE_AVATAR"] ?? "";
@@ -93,17 +126,15 @@ export function resolveConfig(
       storageDriver,
       r2PublicUrl,
       s3PublicUrl,
+      localPublicUrl,
     );
-    siteAvatarUrl = getMediaUrl(siteAvatar, publicUrl);
+    siteAvatarUrl = getMediaUrl(siteAvatar, publicUrl, sitePathPrefix);
   }
 
   // Description is "explicit" when set in DB or ENV (not just the default)
   const dbDescription = allSettings["SITE_DESCRIPTION"];
-  const envDescription = env.SITE_DESCRIPTION;
-  const siteDescriptionExplicit = !!(
-    dbDescription ||
-    (typeof envDescription === "string" && envDescription)
-  );
+  const envDescription = getEnvString(env, "SITE_DESCRIPTION");
+  const siteDescriptionExplicit = !!(dbDescription || envDescription);
 
   return {
     // Site identity (DB > ENV > Default)
@@ -112,6 +143,7 @@ export function resolveConfig(
     siteDescriptionExplicit,
     siteLanguage: resolve("SITE_LANGUAGE", allSettings, env),
     homeDefaultView: resolve("HOME_DEFAULT_VIEW", allSettings, env),
+    mainRssFeed: resolve("MAIN_RSS_FEED", allSettings, env),
     headerNavMaxVisible: (() => {
       const parsed = parseInt(
         resolve("HEADER_NAV_MAX_VISIBLE", allSettings, env),
@@ -119,44 +151,63 @@ export function resolveConfig(
       );
       return Math.max(0, Math.min(5, isNaN(parsed) ? 2 : parsed));
     })(),
-    timeZone: resolve("TIME_ZONE", allSettings, env),
+    timeZone: normalizeTimeZone(resolve("TIME_ZONE", allSettings, env)),
     siteFooter: resolve("SITE_FOOTER", allSettings, env),
-    noindex: resolve("NOINDEX", allSettings, env) === "true",
+    showJantBrandingOnHome:
+      resolve("SHOW_JANT_BRANDING_ON_HOME", allSettings, env) === "true",
+    noindex: demoMode || resolve("NOINDEX", allSettings, env) === "true",
 
     // Infrastructure (ENV only)
-    siteUrl: env.SITE_URL || "",
-    authConfigured: !!env.AUTH_SECRET,
+    siteUrl,
+    siteOrigin,
+    sitePathPrefix,
+    assetBasePath: getPublicAssetBasePath(sitePathPrefix),
+    authConfigured: !!getAuthSecret(env),
 
     // Media (ENV only)
     storageDriver,
     r2PublicUrl,
     s3PublicUrl,
+    localPublicUrl,
     imageTransformUrl,
 
     // Upload (ENV only)
     uploadMaxFileSize:
-      parseInt(env.UPLOAD_MAX_FILE_SIZE_MB ?? "500", 10) || 500,
+      parseInt(getEnvString(env, "UPLOAD_MAX_FILE_SIZE_MB") ?? "500", 10) ||
+      500,
 
     // Summary extraction (ENV only)
-    summaryMaxParagraphs: parseInt(env.SUMMARY_MAX_PARAGRAPHS ?? "5", 10) || 5,
-    summaryMaxChars: parseInt(env.SUMMARY_MAX_CHARS ?? "500", 10) || 500,
+    summaryMaxParagraphs:
+      parseInt(getEnvString(env, "SUMMARY_MAX_PARAGRAPHS") ?? "5", 10) || 5,
+    summaryMaxChars:
+      parseInt(getEnvString(env, "SUMMARY_MAX_CHARS") ?? "500", 10) || 500,
 
     // Slug (ENV only)
-    slugIdLength: parseInt(env.SLUG_ID_LENGTH ?? "5", 10) || 5,
+    slugIdLength: parseInt(getEnvString(env, "SLUG_ID_LENGTH") ?? "5", 10) || 5,
 
     // Pagination/Feed (ENV only)
-    pageSize: parseInt(env.PAGE_SIZE ?? "20", 10) || 20,
-    rssFeedLimit: parseInt(env.RSS_FEED_LIMIT ?? "50", 10) || 50,
+    pageSize,
+    searchPageSize,
+    archivePageSize,
+    rssFeedLimit:
+      parseInt(getEnvString(env, "RSS_FEED_LIMIT") ?? "50", 10) || 50,
 
     // Demo (ENV only)
-    demoEmail: env.DEMO_EMAIL || "",
-    demoPassword: env.DEMO_PASSWORD || "",
+    demoEmail: getEnvString(env, "DEMO_EMAIL") || "",
+    demoPassword: getEnvString(env, "DEMO_PASSWORD") || "",
+    demoMode,
 
     // Theme (DB internal)
     themeId: allSettings["THEME"] ?? "",
     defaultThemeId:
-      env.DEFAULT_THEME || CONFIG_FIELDS.DEFAULT_THEME.defaultValue,
+      getEnvString(env, "DEFAULT_THEME") ||
+      CONFIG_FIELDS.DEFAULT_THEME.defaultValue,
     fontThemeId: allSettings["FONT_THEME"] ?? "",
+    themeMode:
+      allSettings["THEME_MODE"] === "light" ||
+      allSettings["THEME_MODE"] === "dark"
+        ? allSettings["THEME_MODE"]
+        : "auto",
     customCSS: allSettings["CUSTOM_CSS"] ?? "",
 
     // Site appearance (DB internal)

package/src/lib/schemas.ts

@@ -14,10 +14,22 @@ import {
   STATUSES,
   VISIBILITIES,
   SORT_ORDERS,
+  COLLECTION_SORT_ORDERS,
   NAV_ITEM_TYPES,
+  SYSTEM_NAV_KEY_VALUES,
   MAX_MEDIA_ATTACHMENTS,
+  MAX_COLLECTION_SLUG_LENGTH,
+  MAX_COLLECTION_TITLE_LENGTH,
+  MAX_COLLECTION_DESCRIPTION_LENGTH,
+  MAX_SITE_NAME_LENGTH,
+  MAX_SITE_DESCRIPTION_LENGTH,
+  MAX_SITE_FOOTER_LENGTH,
+  TEXT_ATTACHMENT_CONTENT_FORMATS,
+  type ConfigKey,
 } from "../types.js";
 import { ValidationError } from "./errors.js";
+import { createTypeIdSchema, ID_PREFIX } from "./ids.js";
+import { normalizeSlug } from "./slug-format.js";
 import { sanitizeUrl, normalizePath } from "./url.js";
 
 // =============================================================================
@@ -55,6 +67,15 @@ function sanitizeText(maxLength: number) {
     .transform((s) => s.replace(CONTROL_CHAR_RE, "") || undefined);
 }
 
+/** Trim and strip control characters while preserving empty strings. */
+function sanitizeSettingText(maxLength: number) {
+  return z
+    .string()
+    .trim()
+    .max(maxLength)
+    .transform((s) => s.replace(CONTROL_CHAR_RE, ""));
+}
+
 /**
  * Post format enum schema
  * Based on FORMATS from types.ts
@@ -68,14 +89,20 @@ export const FormatSchema = z.enum(FORMATS);
 export const StatusSchema = z.enum(STATUSES);
 
 /**
- * Collection sort order enum schema
+ * Post/general sort order enum schema
  */
 export const SortOrderSchema = z.enum(SORT_ORDERS);
 
+/**
+ * Collection sort order enum schema
+ */
+export const CollectionSortOrderSchema = z.enum(COLLECTION_SORT_ORDERS);
+
 /**
  * Navigation item type enum schema
  */
 export const NavItemTypeSchema = z.enum(NAV_ITEM_TYPES);
+export const SystemNavKeySchema = z.enum(SYSTEM_NAV_KEY_VALUES);
 
 /**
  * Redirect type enum schema
@@ -104,6 +131,15 @@ export const RatingSchema = z.coerce
   .or(z.literal("").transform(() => undefined))
   .transform((v) => (v === 0 ? undefined : v));
 
+const PostIdSchema = createTypeIdSchema(ID_PREFIX.post);
+const MediaIdSchema = createTypeIdSchema(ID_PREFIX.media);
+const CollectionIdSchema = createTypeIdSchema(ID_PREFIX.collection);
+const CollectionDirectoryItemIdSchema = createTypeIdSchema(
+  ID_PREFIX.collectionDirectoryItem,
+);
+const NavItemIdSchema = createTypeIdSchema(ID_PREFIX.navItem);
+const PathIdSchema = createTypeIdSchema(ID_PREFIX.path);
+
 /**
  * Base post fields (shared between create and update schemas)
  */
@@ -131,6 +167,9 @@ const PostFieldsSchema = z.object({
   title: sanitizeText(300)
     .optional()
     .or(z.literal("").transform(() => undefined)),
+  sourceName: sanitizeText(300)
+    .optional()
+    .or(z.literal("").transform(() => undefined)),
   body: z.string().optional(),
   bodyMarkdown: z.string().optional(),
   status: StatusSchema.optional(),
@@ -146,18 +185,70 @@ const PostFieldsSchema = z.object({
     })
     .optional()
     .or(z.literal("")),
+  sourceUrl: z
+    .url()
+    .refine((val) => sanitizeUrl(val) !== "", {
+      message: "URL must use http:, https:, or mailto: protocol",
+    })
+    .optional()
+    .or(z.literal("")),
   quoteText: z.string().optional(),
   rating: RatingSchema,
   collectionIds: z
-    .array(z.string().min(1))
+    .array(CollectionIdSchema)
     .optional()
     .or(z.literal("").transform(() => undefined)),
-  replyToId: z.string().optional(),
+  replyToId: PostIdSchema.optional(),
   publishedAt: z.number().int().positive().optional(),
-  mediaIds: z.array(z.string()).max(MAX_MEDIA_ATTACHMENTS).optional(),
-  mediaAlts: z.record(z.string(), z.string()).optional(),
+  mediaIds: z.array(MediaIdSchema).max(MAX_MEDIA_ATTACHMENTS).optional(),
+  mediaAlts: z.record(MediaIdSchema, z.string()).optional(),
 });
 
+const ApiMediaAttachmentInputSchema = z
+  .object({
+    type: z.literal("media"),
+    mediaId: MediaIdSchema,
+    alt: z
+      .string()
+      .max(500)
+      .transform((s) => s.replace(CONTROL_CHAR_RE, "").trim())
+      .optional()
+      .or(z.literal("").transform(() => "")),
+  })
+  .strict();
+
+const ApiTextAttachmentInputSchema = z
+  .object({
+    type: z.literal("text"),
+    contentFormat: z.enum(TEXT_ATTACHMENT_CONTENT_FORMATS),
+    content: z.string().refine((value) => value.trim().length > 0, {
+      message: "Text attachments need content.",
+    }),
+    summary: sanitizeText(300)
+      .optional()
+      .or(z.literal("").transform(() => undefined)),
+  })
+  .strict();
+
+export const PostAttachmentInputSchema = z.discriminatedUnion("type", [
+  ApiMediaAttachmentInputSchema,
+  ApiTextAttachmentInputSchema,
+]);
+
+const ApiPostFieldsSchema = PostFieldsSchema.omit({
+  mediaIds: true,
+  mediaAlts: true,
+})
+  .extend({
+    attachments: z
+      .array(PostAttachmentInputSchema)
+      .max(MAX_MEDIA_ATTACHMENTS, {
+        message: `Posts allow at most ${MAX_MEDIA_ATTACHMENTS} attachments`,
+      })
+      .optional(),
+  })
+  .strict();
+
 /** Mutual exclusivity: body and bodyMarkdown cannot both be provided */
 function refineBodyExclusivity<
   T extends { body?: string; bodyMarkdown?: string },
@@ -173,11 +264,21 @@ function hasNonEmptyText(value: string | null | undefined): boolean {
 }
 
 function refineCreatePostFormatShape<
-  T extends { format: string; url?: string; quoteText?: string },
+  T extends {
+    format: string;
+    title?: string;
+    sourceName?: string;
+    url?: string;
+    sourceUrl?: string;
+    quoteText?: string;
+  },
 >(schema: z.ZodType<T>) {
   return schema.superRefine((data, ctx) => {
     const hasUrl = hasNonEmptyText(data.url);
+    const hasSourceUrl = hasNonEmptyText(data.sourceUrl);
     const hasQuoteText = hasNonEmptyText(data.quoteText);
+    const hasTitle = hasNonEmptyText(data.title);
+    const hasSourceName = hasNonEmptyText(data.sourceName);
 
     if (data.format === "note") {
       if (hasUrl) {
@@ -194,9 +295,30 @@ function refineCreatePostFormatShape<
           message: "Notes can't include quoted text.",
         });
       }
+      if (hasSourceName) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["sourceName"],
+          message: "Notes can't include a source name.",
+        });
+      }
+      if (hasSourceUrl) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["sourceUrl"],
+          message: "Notes can't include a source URL.",
+        });
+      }
     }
 
     if (data.format === "link") {
+      if (!hasTitle) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["title"],
+          message: "Link posts need a title.",
+        });
+      }
       if (!hasUrl) {
         ctx.addIssue({
           code: z.ZodIssueCode.custom,
@@ -211,6 +333,20 @@ function refineCreatePostFormatShape<
           message: "Link posts can't include quoted text.",
         });
       }
+      if (hasSourceName) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["sourceName"],
+          message: "Link posts can't include a source name.",
+        });
+      }
+      if (hasSourceUrl) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["sourceUrl"],
+          message: "Link posts can't include a source URL.",
+        });
+      }
     }
 
     if (data.format === "quote" && !hasQuoteText) {
@@ -220,6 +356,22 @@ function refineCreatePostFormatShape<
         message: "Quote posts need quoted text.",
       });
     }
+
+    if (data.format === "quote" && hasTitle) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["title"],
+        message: "Quote posts use sourceName instead of title.",
+      });
+    }
+
+    if (data.format === "quote" && hasUrl) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["url"],
+        message: "Quote posts use sourceUrl instead of url.",
+      });
+    }
   });
 }
 
@@ -240,6 +392,10 @@ export const CreatePostSchema = refineSlugPathExclusivity(
   refineCreatePostFormatShape(refineBodyExclusivity(PostFieldsSchema)),
 );
 
+export const CreatePostApiSchema = refineSlugPathExclusivity(
+  refineCreatePostFormatShape(refineBodyExclusivity(ApiPostFieldsSchema)),
+);
+
 /**
  * API request body schema for updating a post
  */
@@ -247,62 +403,86 @@ export const UpdatePostSchema = refineSlugPathExclusivity(
   refineBodyExclusivity(PostFieldsSchema.partial()),
 );
 
+export const UpdatePostApiSchema = refineSlugPathExclusivity(
+  refineBodyExclusivity(ApiPostFieldsSchema.partial()),
+);
+
 /**
  * API request body schema for creating a navigation item
  */
-export const CreateNavItemSchema = z.object({
-  type: NavItemTypeSchema,
-  label: sanitizeText(100).pipe(z.string().min(1)),
+export const CreateNavItemSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("link"),
+    label: sanitizeText(100).pipe(z.string().min(1)),
+    url: z
+      .string()
+      .min(1)
+      .refine((val) => sanitizeUrl(val) !== "", {
+        message: "URL must use http:, https:, or mailto: protocol",
+      }),
+  }),
+  z.object({
+    type: z.literal("system"),
+    systemKey: SystemNavKeySchema,
+  }),
+]);
+
+/**
+ * API request body schema for updating a navigation item
+ */
+export const UpdateNavItemSchema = z.object({
+  label: sanitizeText(100).pipe(z.string().min(1)).optional(),
   url: z
     .string()
     .min(1)
     .refine((val) => sanitizeUrl(val) !== "", {
       message: "URL must use http:, https:, or mailto: protocol",
-    }),
+    })
+    .optional(),
 });
 
-/**
- * API request body schema for updating a navigation item
- */
-export const UpdateNavItemSchema = CreateNavItemSchema.partial();
+export {
+  CollectionDirectoryItemIdSchema,
+  CollectionIdSchema,
+  MediaIdSchema,
+  NavItemIdSchema,
+  PathIdSchema,
+  PostIdSchema,
+};
 
 /**
  * API request body schema for creating a collection
  */
+export const CollectionSlugSchema = z
+  .string()
+  .min(1)
+  .max(MAX_COLLECTION_SLUG_LENGTH, {
+    message: `Keep this link under ${MAX_COLLECTION_SLUG_LENGTH} characters.`,
+  })
+  .transform(normalizeSlug)
+  .pipe(
+    z
+      .string()
+      .min(1)
+      .max(MAX_COLLECTION_SLUG_LENGTH, {
+        message: `Keep this link under ${MAX_COLLECTION_SLUG_LENGTH} characters.`,
+      })
+      .regex(/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/),
+  );
+
+export const CollectionTitleSchema = sanitizeText(
+  MAX_COLLECTION_TITLE_LENGTH,
+).pipe(z.string().min(1));
+
+export const CollectionDescriptionValueSchema = sanitizeText(
+  MAX_COLLECTION_DESCRIPTION_LENGTH,
+);
+
 export const CreateCollectionSchema = z.object({
-  slug: z
-    .string()
-    .min(1)
-    .transform(normalizeSlug)
-    .pipe(
-      z
-        .string()
-        .min(1)
-        .regex(/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/),
-    ),
-  title: sanitizeText(300).pipe(z.string().min(1)),
-  description: sanitizeText(500)
-    .optional()
-    .or(z.literal("").transform(() => undefined)),
-  icon: z
-    .string()
-    .optional()
-    .refine(
-      (val) => {
-        if (!val || !val.startsWith("{")) return true;
-        try {
-          const parsed = JSON.parse(val) as Record<string, unknown>;
-          if (typeof parsed.color === "string") {
-            return /^#[0-9a-f]{3,6}$/i.test(parsed.color);
-          }
-          return true;
-        } catch {
-          return true; // non-JSON icons (legacy emoji) are fine
-        }
-      },
-      { message: "Icon color must be a valid hex color (e.g. #fff, #ff0000)" },
-    ),
-  sortOrder: SortOrderSchema.optional(),
+  slug: CollectionSlugSchema,
+  title: CollectionTitleSchema,
+  description: CollectionDescriptionValueSchema.optional(),
+  sortOrder: CollectionSortOrderSchema.optional(),
 });
 
 /**
@@ -310,6 +490,36 @@ export const CreateCollectionSchema = z.object({
  */
 export const UpdateCollectionSchema = CreateCollectionSchema.partial();
 
+export const SiteNameSettingSchema = sanitizeSettingText(MAX_SITE_NAME_LENGTH);
+export const SiteDescriptionSettingSchema = sanitizeSettingText(
+  MAX_SITE_DESCRIPTION_LENGTH,
+);
+export const SiteFooterSettingSchema = sanitizeSettingText(
+  MAX_SITE_FOOTER_LENGTH,
+);
+
+export const UpdateSiteSettingsSchema = z.object({
+  siteName: SiteNameSettingSchema,
+  siteDescription: SiteDescriptionSettingSchema,
+  siteFooter: SiteFooterSettingSchema,
+});
+
+const EDITABLE_SETTING_VALUE_SCHEMAS: Partial<
+  Record<ConfigKey, z.ZodSchema<string>>
+> = {
+  SITE_NAME: SiteNameSettingSchema,
+  SITE_DESCRIPTION: SiteDescriptionSettingSchema,
+  SITE_FOOTER: SiteFooterSettingSchema,
+};
+
+export function normalizeEditableSettingValue(
+  key: ConfigKey,
+  value: string,
+): string {
+  const schema = EDITABLE_SETTING_VALUE_SCHEMAS[key];
+  return schema ? parseValidated(schema, value) : value;
+}
+
 /**
  * API request body schema for creating a custom URL
  */
@@ -379,26 +589,7 @@ export const ResetPasswordSchema = z
 // Slug Normalization
 // =============================================================================
 
-/**
- * Normalize a string into a valid slug format.
- * Lowercases, replaces non-alphanumeric characters with dashes,
- * collapses consecutive dashes, and trims leading/trailing dashes.
- *
- * @param s - Raw input string
- * @returns Normalized slug
- * @example
- * ```ts
- * normalizeSlug("My Cool Page!") // "my-cool-page"
- * normalizeSlug("  hello  world  ") // "hello-world"
- * ```
- */
-export function normalizeSlug(s: string): string {
-  return s
-    .toLowerCase()
-    .replace(/[^a-z0-9-]/g, "-")
-    .replace(/-{2,}/g, "-")
-    .replace(/^-|-$/g, "");
-}
+export { normalizeSlug } from "./slug-format.js";
 
 // =============================================================================
 // Form Data Helpers
@@ -447,15 +638,15 @@ export function parseFormDataOptional<T>(
 }
 
 /**
- * Validates media attachment count for a post.
- * All formats allow 0-20 media attachments.
+ * Validates attachment count for a post.
+ * All formats allow 0-20 attachments.
  *
- * @param mediaIds - Array of media IDs to attach
+ * @param attachments - Array of attachments to attach
  * @returns null if valid, error string if invalid
  */
-export function validateMediaCount(mediaIds: string[]): string | null {
-  if (mediaIds.length > MAX_MEDIA_ATTACHMENTS) {
-    return `Posts allow at most ${MAX_MEDIA_ATTACHMENTS} media attachments`;
+export function validateAttachmentCount(attachments: unknown[]): string | null {
+  if (attachments.length > MAX_MEDIA_ATTACHMENTS) {
+    return `Posts allow at most ${MAX_MEDIA_ATTACHMENTS} attachments`;
   }
   return null;
 }