@jant/core 0.6.14 → 0.6.15

package/src/lib/resolve-config.ts

@@ -42,15 +42,19 @@ function resolve(
   const envKeys = "envKeys" in field ? field.envKeys : undefined;
 
   // User-configurable: DB > ENV > Default
-  if (!field.envOnly) {
-    const dbValue = allSettings[key];
-    if (dbValue) return dbValue;
+  if (!field.envOnly && Object.hasOwn(allSettings, key)) {
+    return allSettings[key] ?? "";
   }
 
   // ENV > Default
   const envValue = getEnvString(env, ...(envKeys ?? []));
   if (envValue) return envValue;
 
+  if (field.defaultValue) return field.defaultValue;
+  if ("fallbackKey" in field && field.fallbackKey) {
+    return resolve(field.fallbackKey, allSettings, env);
+  }
+
   return field.defaultValue;
 }
 
@@ -70,12 +74,73 @@ function resolveFallback(key: string, env: Bindings): string {
   const envValue = getEnvString(env, ...(envKeys ?? []));
   if (envValue) return envValue;
 
+  if (field.defaultValue) return field.defaultValue;
+  if ("fallbackKey" in field && field.fallbackKey) {
+    return resolveFallback(field.fallbackKey, env);
+  }
+
   return field.defaultValue;
 }
 
-function parseConfigInt(value: string, fallback: number): number {
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+type RuntimeNumberConfigKey =
+  | "PAGE_SIZE"
+  | "SEARCH_PAGE_SIZE"
+  | "ARCHIVE_PAGE_SIZE"
+  | "SUMMARY_MAX_PARAGRAPHS"
+  | "SUMMARY_MAX_CHARS"
+  | "RSS_FEED_LIMIT"
+  | "RSS_PUBLISH_DELAY_SECONDS";
+
+function parseConfigInt(
+  key: RuntimeNumberConfigKey,
+  value: string,
+  fallback: number,
+): number {
+  const normalized = value.trim();
+  const parsed = Number(normalized);
+  const definition = CONFIG_FIELDS[key].editor;
+  return normalized.length > 0 &&
+    Number.isInteger(parsed) &&
+    (definition.min === undefined || parsed >= definition.min) &&
+    (definition.max === undefined || parsed <= definition.max)
+    ? parsed
+    : fallback;
+}
+
+/**
+ * Resolve the runtime limits used for automatic post summaries.
+ *
+ * Internal maintenance routes run before the full config middleware, so they
+ * use this focused resolver instead of assuming `c.var.appConfig` exists.
+ *
+ * @param env - Runtime bindings.
+ * @param allSettings - DB settings map when available.
+ * @returns Positive summary extraction limits with configured defaults.
+ * @example
+ * ```ts
+ * resolveSummaryConfig({ SUMMARY_MAX_CHARS: "240" }).maxChars;
+ * // 240
+ * ```
+ */
+export function resolveSummaryConfig(
+  env: Bindings,
+  allSettings: Record<string, string> = {},
+): {
+  maxParagraphs: number;
+  maxChars: number;
+} {
+  return {
+    maxParagraphs: parseConfigInt(
+      "SUMMARY_MAX_PARAGRAPHS",
+      resolve("SUMMARY_MAX_PARAGRAPHS", allSettings, env),
+      5,
+    ),
+    maxChars: parseConfigInt(
+      "SUMMARY_MAX_CHARS",
+      resolve("SUMMARY_MAX_CHARS", allSettings, env),
+      500,
+    ),
+  };
 }
 
 function parseFeedKind(value: string, fallback: FeedKind): FeedKind {
@@ -102,12 +167,19 @@ export function resolveConfig(
   allSettings: Record<string, string>,
   options?: { siteUrl?: string },
 ): AppConfig {
-  const pageSize = parseConfigInt(resolve("PAGE_SIZE", allSettings, env), 50);
+  const summaryConfig = resolveSummaryConfig(env, allSettings);
+  const pageSize = parseConfigInt(
+    "PAGE_SIZE",
+    resolve("PAGE_SIZE", allSettings, env),
+    50,
+  );
   const searchPageSize = parseConfigInt(
+    "SEARCH_PAGE_SIZE",
     resolve("SEARCH_PAGE_SIZE", allSettings, env),
     pageSize,
   );
   const archivePageSize = parseConfigInt(
+    "ARCHIVE_PAGE_SIZE",
     resolve("ARCHIVE_PAGE_SIZE", allSettings, env),
     pageSize,
   );
@@ -137,9 +209,12 @@ export function resolveConfig(
   }
 
   // Description is "explicit" when set in DB or ENV (not just the default)
+  const hasDbDescription = Object.hasOwn(allSettings, "SITE_DESCRIPTION");
   const dbDescription = allSettings["SITE_DESCRIPTION"];
   const envDescription = getEnvString(env, "SITE_DESCRIPTION");
-  const siteDescriptionExplicit = !!(dbDescription || envDescription);
+  const siteDescriptionExplicit = hasDbDescription
+    ? !!dbDescription
+    : !!envDescription;
 
   return {
     // Site identity (DB > ENV > Default)
@@ -158,6 +233,9 @@ export function resolveConfig(
     showJantBrandingOnHome:
       resolve("SHOW_JANT_BRANDING_ON_HOME", allSettings, env) === "true",
     noindex: demoMode || resolve("NOINDEX", allSettings, env) === "true",
+    publicApiEnabled:
+      resolve("PUBLIC_API_ENABLED", allSettings, env) === "true",
+    rssFeedsEnabled: resolve("RSS_FEEDS_ENABLED", allSettings, env) === "true",
 
     // Infrastructure (ENV only)
     siteUrl,
@@ -185,21 +263,27 @@ export function resolveConfig(
       parseInt(getEnvString(env, "UPLOAD_MAX_FILE_SIZE_MB") ?? "1024", 10) ||
       1024,
 
-    // Summary extraction (ENV only)
-    summaryMaxParagraphs:
-      parseInt(getEnvString(env, "SUMMARY_MAX_PARAGRAPHS") ?? "5", 10) || 5,
-    summaryMaxChars:
-      parseInt(getEnvString(env, "SUMMARY_MAX_CHARS") ?? "500", 10) || 500,
+    // Summary extraction (DB > ENV > Default)
+    summaryMaxParagraphs: summaryConfig.maxParagraphs,
+    summaryMaxChars: summaryConfig.maxChars,
 
     // Slug (ENV only)
     slugIdLength: parseInt(getEnvString(env, "SLUG_ID_LENGTH") ?? "5", 10) || 5,
 
-    // Pagination/Feed (ENV only)
+    // Pagination/feed (DB > ENV > Default)
     pageSize,
     searchPageSize,
     archivePageSize,
-    rssFeedLimit:
-      parseInt(getEnvString(env, "RSS_FEED_LIMIT") ?? "50", 10) || 50,
+    rssFeedLimit: parseConfigInt(
+      "RSS_FEED_LIMIT",
+      resolve("RSS_FEED_LIMIT", allSettings, env),
+      50,
+    ),
+    rssPublishDelaySeconds: parseConfigInt(
+      "RSS_PUBLISH_DELAY_SECONDS",
+      resolve("RSS_PUBLISH_DELAY_SECONDS", allSettings, env),
+      300,
+    ),
 
     // Demo (ENV only)
     demoEmail: getEnvString(env, "DEMO_EMAIL") || "",

package/src/lib/schemas.ts

@@ -26,13 +26,22 @@ import {
   MAX_SITE_DESCRIPTION_LENGTH,
   MAX_SITE_FOOTER_LENGTH,
   TEXT_ATTACHMENT_CONTENT_FORMATS,
+  CONFIG_FIELDS,
+  type ConfigEditorDefinition,
   type ConfigKey,
 } from "../types.js";
+import { isCjkSerifFont } from "../i18n/detect.js";
+import {
+  isLocale,
+  isValidContentLanguage,
+  normalizeContentLanguage,
+} from "../i18n/locales.js";
 import { ValidationError } from "./errors.js";
 import { createTypeIdSchema, ID_PREFIX } from "./ids.js";
 import { normalizeSlug } from "./slug-format.js";
 import { isReservedPath } from "./constants.js";
 import { sanitizeUrl, normalizePath } from "./url.js";
+import { isSupportedTimeZone, normalizeTimeZone } from "./timezones.js";
 
 // =============================================================================
 // Shared Transforms
@@ -557,6 +566,12 @@ export const CreateNavItemSchema = z.discriminatedUnion("type", [
     label: sanitizeText(100).pipe(z.string().min(1)).optional(),
     placement: z.enum(["header", "more"]).optional(),
   }),
+  z.object({
+    type: z.literal("page"),
+    postId: PostIdSchema,
+    label: sanitizeText(100).pipe(z.string().min(1)).optional(),
+    placement: z.enum(["header", "more"]).optional(),
+  }),
 ]);
 
 /**
@@ -684,12 +699,129 @@ const EDITABLE_SETTING_VALUE_SCHEMAS: Partial<
   SITE_FOOTER: SiteFooterSettingSchema,
 };
 
+/**
+ * Normalize a raw string according to a Config Editor control definition.
+ *
+ * @param definition - Typed editor metadata from the config registry
+ * @param value - Raw string received at the HTTP/service boundary
+ * @returns Canonical string suitable for the settings key-value store
+ * @example
+ * ```ts
+ * normalizeConfigEditorDefinitionValue({ type: "boolean" }, "true");
+ * // "true"
+ * ```
+ */
+export function normalizeConfigEditorDefinitionValue(
+  definition: ConfigEditorDefinition,
+  value: string,
+): string {
+  switch (definition.type) {
+    case "boolean": {
+      const normalized = value.trim().toLowerCase();
+      if (normalized !== "true" && normalized !== "false") {
+        throw new ValidationError("Choose true or false.");
+      }
+      return normalized;
+    }
+    case "string": {
+      const normalized = value.trim();
+      if (
+        definition.maxLength !== undefined &&
+        normalized.length > definition.maxLength
+      ) {
+        throw new ValidationError(
+          `Keep this value at ${definition.maxLength} characters or fewer.`,
+        );
+      }
+      return normalized;
+    }
+    case "number": {
+      const normalized = value.trim();
+      const parsed = Number(normalized);
+      if (!normalized || !Number.isFinite(parsed)) {
+        throw new ValidationError("Enter a valid number.");
+      }
+      if (definition.min !== undefined && parsed < definition.min) {
+        throw new ValidationError(
+          `Enter a number greater than or equal to ${definition.min}.`,
+        );
+      }
+      if (definition.max !== undefined && parsed > definition.max) {
+        throw new ValidationError(
+          `Enter a number less than or equal to ${definition.max}.`,
+        );
+      }
+      if (definition.step !== undefined && definition.step > 0) {
+        const steps = parsed / definition.step;
+        const tolerance = Number.EPSILON * Math.max(1, Math.abs(steps)) * 4;
+        if (Math.abs(steps - Math.round(steps)) > tolerance) {
+          throw new ValidationError(
+            `Enter a number in steps of ${definition.step}.`,
+          );
+        }
+      }
+      return String(parsed);
+    }
+    case "enum": {
+      if (definition.options && !definition.options.includes(value)) {
+        throw new ValidationError("Choose one of the available options.");
+      }
+      return value;
+    }
+  }
+}
+
 export function normalizeEditableSettingValue(
   key: ConfigKey,
   value: string,
 ): string {
+  const field = CONFIG_FIELDS[key];
+  if (!("editor" in field)) {
+    return value;
+  }
+
   const schema = EDITABLE_SETTING_VALUE_SCHEMAS[key];
-  return schema ? parseValidated(schema, value) : value;
+  let normalized = schema
+    ? parseValidated(schema, value)
+    : normalizeConfigEditorDefinitionValue(field.editor, value);
+
+  switch (key) {
+    case "SITE_NAME":
+      if (!normalized) {
+        throw new ValidationError(
+          "Site name can't be empty. Enter a name or reset this setting.",
+        );
+      }
+      break;
+    case "SITE_LANGUAGE":
+      if (!isValidContentLanguage(normalized)) {
+        throw new ValidationError(
+          "Enter a valid BCP 47 language tag, such as en, fi, or zh-Hans.",
+        );
+      }
+      normalized = normalizeContentLanguage(normalized);
+      break;
+    case "DASHBOARD_LANGUAGE":
+      if (normalized && !isLocale(normalized)) {
+        throw new ValidationError(
+          "Choose a dashboard language Jant is translated into.",
+        );
+      }
+      break;
+    case "CJK_SERIF_FONT":
+      if (!isCjkSerifFont(normalized)) {
+        throw new ValidationError("Choose an available CJK font fallback.");
+      }
+      break;
+    case "TIME_ZONE":
+      if (!isSupportedTimeZone(normalized)) {
+        throw new ValidationError("Choose a valid time zone.");
+      }
+      normalized = normalizeTimeZone(normalized);
+      break;
+  }
+
+  return normalized;
 }
 
 /**

package/src/lib/settings-paths.ts

@@ -0,0 +1,5 @@
+/**
+ * Canonical paths for settings pages shared by server and client UI.
+ */
+
+export const NAVIGATION_SETTINGS_PATH = "/settings/navigation";

package/src/lib/site-skill.ts

@@ -0,0 +1,78 @@
+import SITE_SKILL_TEMPLATE from "../../../../docs/skill.md?raw";
+import { normalizeSiteUrl } from "./url.js";
+
+const INTRODUCTION =
+  "This page is written for AI assistants working with one Jant site. Use it when the user asks you to read, publish, edit, organize, search, or migrate site content through Jant's HTTP API or MCP interface.";
+const GENERIC_SITE_URL = "https://example.com";
+const GENERIC_SITE_CONFIRMATION = `- The Jant site URL (e.g. \`${GENERIC_SITE_URL}\`).`;
+const GENERIC_SITE_EXPORT = `export JANT_SITE=${GENERIC_SITE_URL}\n`;
+const GENERIC_SITE_MARKERS = [
+  GENERIC_SITE_CONFIRMATION,
+  GENERIC_SITE_EXPORT,
+  "<site>",
+  "$JANT_SITE",
+];
+
+function replaceLiteral(
+  content: string,
+  search: string,
+  replacement: string,
+): string {
+  return content.replaceAll(search, () => replacement);
+}
+
+/**
+ * Render the Agent skill for one concrete Jant site.
+ *
+ * @param siteUrl - Resolved public site URL, including any path prefix
+ * @returns Markdown with every target-site placeholder bound to `siteUrl`
+ * @example
+ * ```ts
+ * renderSiteSkill("https://example.com/blog");
+ * ```
+ */
+export function renderSiteSkill(siteUrl: string): string {
+  const normalizedSiteUrl = normalizeSiteUrl(siteUrl);
+  if (!normalizedSiteUrl) {
+    throw new Error("A public site URL is required to render /skill.md");
+  }
+
+  const targetSiteUrl = normalizedSiteUrl.replace(/\/$/, "");
+  if (!SITE_SKILL_TEMPLATE.includes(INTRODUCTION)) {
+    throw new Error("The site skill template introduction could not be found");
+  }
+  const missingMarker = GENERIC_SITE_MARKERS.find(
+    (marker) => !SITE_SKILL_TEMPLATE.includes(marker),
+  );
+  if (missingMarker) {
+    throw new Error(
+      `The site skill template target marker could not be found: ${missingMarker}`,
+    );
+  }
+
+  let content = SITE_SKILL_TEMPLATE;
+  content = replaceLiteral(content, GENERIC_SITE_EXPORT, "");
+  content = replaceLiteral(
+    content,
+    GENERIC_SITE_CONFIRMATION,
+    `- That the target Jant site is \`${targetSiteUrl}\`.`,
+  );
+  content = replaceLiteral(content, "<site>", targetSiteUrl);
+  content = replaceLiteral(content, "$JANT_SITE", targetSiteUrl);
+  content = replaceLiteral(
+    content,
+    INTRODUCTION,
+    `${INTRODUCTION}\n\nThis site-scoped copy is bound to <${targetSiteUrl}>. Send every API request in this guide to this exact base URL. Do not substitute another target without the user's confirmation.`,
+  );
+
+  const unresolvedMarker = ["<site>", "$JANT_SITE"].find((marker) =>
+    content.includes(marker),
+  );
+  if (unresolvedMarker) {
+    throw new Error(
+      `The site skill template contains an unresolved target marker: ${unresolvedMarker}`,
+    );
+  }
+
+  return content;
+}

package/src/lib/summary.ts

@@ -6,7 +6,10 @@
  */
 
 import type { JSONContent } from "@tiptap/core";
-import { renderTiptapDocument } from "./tiptap-render.js";
+import {
+  renderTiptapDocument,
+  type TiptapRenderOptions,
+} from "./tiptap-render.js";
 
 interface TiptapNode {
   type: string;
@@ -220,6 +223,7 @@ export function extractSummary(
  *   included and `hasMore` is `false`. Avoids a "read more" that reveals only a
  *   sliver of text. Explicit `moreBreak` markers reflect author intent and are
  *   never subject to this tolerance.
+ * @param renderOptions - Renderer options such as the post footnote namespace
  * @returns HTML summary, whether content was truncated, and the index in
  *   `doc.content` where the content after the summary boundary begins, or null.
  *   `breakAtIndex` lets callers align the summary with the full-body rendering
@@ -236,6 +240,7 @@ export function extractSummaryHtml(
   maxBlocks: number = 5,
   maxChars: number = 500,
   minHiddenChars: number = 0,
+  renderOptions: TiptapRenderOptions = {},
 ): { html: string; hasMore: boolean; breakAtIndex: number } | null {
   let doc: TiptapNode;
   try {
@@ -260,10 +265,13 @@ export function extractSummaryHtml(
     if (selected.length === 0) return null;
     const subDoc: JSONContent = {
       type: "doc",
-      content: selected as JSONContent[],
+      content: [
+        ...selected,
+        ...nodes.filter((node) => node.type === "footnoteDefinition"),
+      ] as JSONContent[],
     };
     return {
-      html: renderTiptapDocument(subDoc),
+      html: renderTiptapDocument(subDoc, renderOptions),
       hasMore: true,
       // Anchor goes in place of the moreBreak marker, so the marker itself
       // is NOT part of the pre-anchor body. It remains in the post-anchor
@@ -329,10 +337,13 @@ export function extractSummaryHtml(
 
   const subDoc: JSONContent = {
     type: "doc",
-    content: selected as JSONContent[],
+    content: [
+      ...selected,
+      ...nodes.filter((node) => node.type === "footnoteDefinition"),
+    ] as JSONContent[],
   };
   return {
-    html: renderTiptapDocument(subDoc),
+    html: renderTiptapDocument(subDoc, renderOptions),
     hasMore,
     breakAtIndex: lastSelectedIdx + 1,
   };