@jant/core 0.6.14 → 0.6.16

package/src/lib/__tests__/tiptap-to-markdown.test.ts

@@ -402,6 +402,12 @@ describe("tiptapJsonToMarkdown", () => {
       const md = "Body copy[^1]\n\n[^1]: Footnote body";
       expect(roundtrip(md)).toBe(md);
     });
+
+    it("canonicalizes inline footnotes as references plus definitions", () => {
+      expect(roundtrip("Body^[Inline **bold** note.]")).toBe(
+        "Body[^1]\n\n[^1]: Inline **bold** note.",
+      );
+    });
   });
 
   describe("edge cases", () => {

package/src/lib/__tests__/translit.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect } from "vitest";
+import { hangulToLatin, kanaToRomaji } from "../translit.js";
+
+describe("hangulToLatin", () => {
+  it("romanizes basic syllables", () => {
+    expect(hangulToLatin("안녕하세요")).toBe("annyeonghaseyo");
+  });
+
+  it("applies liaison before silent-ㅇ syllables", () => {
+    expect(hangulToLatin("한국어")).toBe("hangugeo");
+    expect(hangulToLatin("일지")).toBe("ilji");
+  });
+
+  it("drops carried ㅎ in liaison", () => {
+    expect(hangulToLatin("좋아")).toBe("joa");
+  });
+
+  it("splits compound finals in liaison", () => {
+    expect(hangulToLatin("읽어")).toBe("ilgeo");
+    expect(hangulToLatin("값이")).toBe("gapsi");
+  });
+
+  it("keeps final ㅇ as ng before vowels", () => {
+    expect(hangulToLatin("강아지")).toBe("gangaji");
+  });
+
+  it("uses phonetic finals", () => {
+    expect(hangulToLatin("옷")).toBe("ot");
+    expect(hangulToLatin("부엌")).toBe("bueok");
+  });
+
+  it("preserves spaces and non-hangul characters", () => {
+    expect(hangulToLatin("개발 일지 3일차")).toBe("gaebal ilji 3ilcha");
+    expect(hangulToLatin("React 공부")).toBe("React gongbu");
+  });
+
+  it("romanizes standalone compatibility jamo", () => {
+    expect(hangulToLatin("ㅋㅋㅋ")).toBe("kkk");
+    expect(hangulToLatin("ㅠㅠ")).toBe("yuyu");
+  });
+});
+
+describe("kanaToRomaji", () => {
+  it("romanizes hiragana", () => {
+    expect(kanaToRomaji("こんにちは")).toBe("konnichiha");
+  });
+
+  it("romanizes katakana", () => {
+    expect(kanaToRomaji("カタカナタイトル")).toBe("katakanataitoru");
+  });
+
+  it("drops the chōonpu long-vowel mark", () => {
+    expect(kanaToRomaji("ハンバーガー")).toBe("hanbaga");
+    expect(kanaToRomaji("ラーメン")).toBe("ramen");
+  });
+
+  it("geminates consonants after sokuon", () => {
+    expect(kanaToRomaji("がっこう")).toBe("gakkou");
+    expect(kanaToRomaji("きっぷ")).toBe("kippu");
+  });
+
+  it("uses tch for sokuon before chi", () => {
+    expect(kanaToRomaji("まっちゃ")).toBe("matcha");
+  });
+
+  it("handles digraphs", () => {
+    expect(kanaToRomaji("きょうと")).toBe("kyouto");
+    expect(kanaToRomaji("しゃしん")).toBe("shashin");
+    expect(kanaToRomaji("じゅんび")).toBe("junbi");
+  });
+
+  it("handles extended katakana combos", () => {
+    expect(kanaToRomaji("ファン")).toBe("fan");
+    expect(kanaToRomaji("パーティー")).toBe("pati");
+    expect(kanaToRomaji("チェック")).toBe("chekku");
+    expect(kanaToRomaji("ヴァイオリン")).toBe("vaiorin");
+  });
+
+  it("passes non-kana characters through unchanged", () => {
+    expect(kanaToRomaji("東京タワー")).toBe("東京tawa");
+    expect(kanaToRomaji("abc カフェ")).toBe("abc kafe");
+  });
+
+  it("ignores a dangling sokuon", () => {
+    expect(kanaToRomaji("あっ")).toBe("a");
+  });
+});

package/src/lib/__tests__/url.test.ts

@@ -5,6 +5,8 @@ import {
   isFullUrl,
   isSafeAbsoluteUrl,
   normalizePath,
+  sanitizeRichTextHref,
+  sanitizeUrl,
   stripSitePathPrefix,
   slugify,
   toSameSitePath,
@@ -211,6 +213,22 @@ describe("isSafeAbsoluteUrl", () => {
   });
 });
 
+describe("URL sanitizers", () => {
+  it("keeps action protocols scoped to rich-text links", () => {
+    expect(sanitizeRichTextHref("tel:+15551234567")).toBe("tel:+15551234567");
+    expect(sanitizeRichTextHref("sms:xxxxx@xx.com")).toBe("sms:xxxxx@xx.com");
+
+    expect(sanitizeUrl("tel:+15551234567")).toBe("");
+    expect(sanitizeUrl("sms:xxxxx@xx.com")).toBe("");
+  });
+
+  it("rejects executable protocols in every context", () => {
+    expect(sanitizeRichTextHref("javascript:alert(1)")).toBe("");
+    expect(sanitizeRichTextHref("data:text/html,<h1>Hi</h1>")).toBe("");
+    expect(sanitizeUrl("javascript:alert(1)")).toBe("");
+  });
+});
+
 describe("slugify", () => {
   it("converts text to lowercase hyphenated slug", () => {
     expect(slugify("Hello World")).toBe("hello-world");
@@ -257,6 +275,41 @@ describe("slugify", () => {
   it("handles CJK characters with spaces", () => {
     expect(slugify("电影 评论")).toBe("dian-ying-ping-lun");
   });
+
+  it("romanizes Korean titles", () => {
+    expect(slugify("안녕하세요 세계")).toBe("annyeonghaseyo-segye");
+    expect(slugify("개발 일지 3일차")).toBe("gaebal-ilji-3ilcha");
+  });
+
+  it("romanizes kana-only Japanese titles", () => {
+    expect(slugify("カタカナタイトル")).toBe("katakanataitoru");
+    expect(slugify("ハンバーガー")).toBe("hanbaga");
+  });
+
+  it("keeps Latin words in mostly-kana Japanese titles", () => {
+    expect(slugify("React入門ガイド")).toBe("react-gaido");
+  });
+
+  it("returns empty for kanji-heavy Japanese titles instead of garbling them", () => {
+    // Kanji carries the meaning; without a reading dictionary any output
+    // would be gibberish, so callers should fall back to a random ID.
+    expect(slugify("日本語のタイトルです")).toBe("");
+    expect(slugify("東京タワーに行った")).toBe("");
+    expect(slugify("こんにちは世界")).toBe("");
+  });
+
+  it("returns empty for scripts with no usable transliteration", () => {
+    expect(slugify("שלום עולם")).toBe("");
+    expect(slugify("สวัสดีชาวโลก")).toBe("");
+  });
+
+  it("returns empty when most of the title is untransliterable", () => {
+    expect(slugify("שלום world")).toBe("");
+  });
+
+  it("returns empty for emoji-only titles", () => {
+    expect(slugify("🎉🎉")).toBe("");
+  });
 });
 
 describe("stripSitePathPrefix", () => {

package/src/lib/__tests__/view.test.ts

@@ -20,6 +20,7 @@ import type {
   SearchResult,
   Post,
 } from "../../types.js";
+import { renderTiptapJson } from "../tiptap-render.js";
 const EMPTY_CTX: MediaContext = {};
 const CTX_WITH_URLS: MediaContext = {
   r2PublicUrl: "https://cdn.example.com",
@@ -271,6 +272,58 @@ describe("toPostView", () => {
     );
   });
 
+  it("places the summary boundary after a footnote repeated in the hidden tail", () => {
+    const firstText = "A".repeat(300);
+    const secondText = "B".repeat(300);
+    const body = JSON.stringify({
+      type: "doc",
+      content: [
+        {
+          type: "paragraph",
+          content: [
+            { type: "text", text: firstText },
+            { type: "footnoteReference", attrs: { label: "shared" } },
+          ],
+        },
+        {
+          type: "paragraph",
+          content: [
+            { type: "text", text: secondText },
+            { type: "footnoteReference", attrs: { label: "shared" } },
+          ],
+        },
+        {
+          type: "footnoteDefinition",
+          attrs: { label: "shared" },
+          content: [
+            {
+              type: "paragraph",
+              content: [{ type: "text", text: "Shared definition" }],
+            },
+          ],
+        },
+      ],
+    });
+    const bodyHtml = renderTiptapJson(body, { namespace: UUID_1 });
+    const view = toPostView(
+      makePostWithMedia({ title: "Article", body, bodyHtml }),
+      EMPTY_CTX,
+    );
+
+    expect(view.summaryHasMore).toBe(true);
+    const markerIndex = view.bodyHtml?.indexOf('<span id="continue"></span>');
+    expect(markerIndex).toBeGreaterThan(
+      view.bodyHtml?.indexOf(firstText) ?? -1,
+    );
+    expect(markerIndex).toBeLessThan(view.bodyHtml?.indexOf(secondText) ?? -1);
+    expect(view.bodyHtml).toContain('href="#fnref-1jp3895hp1ag7-1-2"');
+    expect(view.bodyHtml).not.toContain("footnote-document");
+    expect(view.bodyHtml?.match(/<ol class="footnote-list">/g)).toHaveLength(1);
+    expect(view.bodyHtml?.indexOf("Shared definition")).toBeGreaterThan(
+      view.bodyHtml?.indexOf(secondText) ?? -1,
+    );
+  });
+
   it("does not attach summaryHtml for short untitled notes", () => {
     const body = JSON.stringify({
       type: "doc",

package/src/lib/__tests__/worker-response-cache.test.ts

@@ -1,6 +1,10 @@
 import { describe, expect, it } from "vitest";
 import type { Bindings } from "../../types.js";
-import { withWorkerResponseCache } from "../worker-response-cache.js";
+import { POST_BODY_HTML_VERSION } from "../post-body-html.js";
+import {
+  normalizeWorkerCacheKeyUrl,
+  withWorkerResponseCache,
+} from "../worker-response-cache.js";
 
 interface StoredResponse {
   body: Uint8Array;
@@ -59,6 +63,19 @@ function createCloudflareBindings(overrides: Partial<Bindings> = {}): Bindings {
 }
 
 describe("withWorkerResponseCache", () => {
+  it("versions cache keys with the current body HTML contract", () => {
+    const url = new URL(
+      normalizeWorkerCacheKeyUrl(
+        "https://example.com/feed?__jant_body_html=old&utm_source=test",
+      ),
+    );
+
+    expect(url.searchParams.get("__jant_body_html")).toBe(
+      String(POST_BODY_HTML_VERSION),
+    );
+    expect(url.searchParams.has("utm_source")).toBe(false);
+  });
+
   it("caches anonymous phase-one feed responses and normalizes tracking params", async () => {
     const cache = createMemoryCache();
     const bindings = createCloudflareBindings();

package/src/lib/api-settings.ts

@@ -1,31 +1,258 @@
-import { CONFIG_FIELDS, type ConfigKey } from "../types.js";
+import {
+  CONFIG_FIELDS,
+  type Bindings,
+  type ConfigEditorDefinition,
+  type ConfigEditorFieldState,
+  type ConfigEditorKey,
+  type ConfigEditorResettableKey,
+  type ConfigEditorVisibleKey,
+  type ConfigKey,
+} from "../types.js";
+import { getSupportedLocaleEntries } from "../i18n/supported-locales.js";
 import { SETTINGS_KEYS } from "./constants.js";
-import { normalizeTimeZone } from "./timezones.js";
+import { getEnvString } from "./env.js";
+import { normalizeEditableSettingValue } from "./schemas.js";
+import { getTimeZoneOptions } from "./timezones.js";
 
 export const demoLockedSettingKeys = new Set<ConfigKey>(["NOINDEX"]);
 
-/** Config keys that can be modified via the settings API */
+/** Config keys explicitly approved for runtime editing. */
 export const editableSettingKeys = Object.entries(CONFIG_FIELDS)
+  .filter(([, field]) => "editor" in field)
+  .map(([key]) => key as ConfigEditorKey);
+
+/** Safe settings shown in Config Editor, including dedicated-page links. */
+export const configEditorVisibleKeys = Object.entries(CONFIG_FIELDS)
+  .filter(([, field]) => "editor" in field || "configEditorLink" in field)
+  .map(([key]) => key as ConfigEditorVisibleKey);
+
+/** Config Editor keys whose DB override can be safely removed directly. */
+export const resettableConfigEditorKeys = Object.entries(CONFIG_FIELDS)
   .filter(
-    ([, field]) => !field.envOnly && !("internal" in field && field.internal),
+    ([, field]) =>
+      "editor" in field ||
+      ("configEditorLink" in field &&
+        "resettable" in field.configEditorLink &&
+        field.configEditorLink.resettable === true),
   )
-  .map(([key]) => key as ConfigKey);
+  .map(([key]) => key as ConfigEditorResettableKey);
+
+export function isEditableSettingKey(key: string): key is ConfigEditorKey {
+  return editableSettingKeys.includes(key as ConfigEditorKey);
+}
+
+export function isResettableConfigEditorKey(
+  key: string,
+): key is ConfigEditorResettableKey {
+  return resettableConfigEditorKeys.includes(key as ConfigEditorResettableKey);
+}
+
+function tryNormalizeResolvedSettingValue(
+  key: ConfigEditorKey,
+  value: string,
+): string | undefined {
+  try {
+    return normalizeEditableSettingValue(key, value);
+  } catch {
+    return undefined;
+  }
+}
+
+export function getEditableSettingFallbackValue(
+  key: ConfigEditorKey,
+  env?: Bindings,
+  allSettings: Record<string, string> = {},
+): string {
+  const field = CONFIG_FIELDS[key];
+  const envKeys = "envKeys" in field ? field.envKeys : undefined;
+  const envValue = env ? getEnvString(env, ...(envKeys ?? [])) : undefined;
+  if (envValue) {
+    const normalizedEnv = tryNormalizeResolvedSettingValue(key, envValue);
+    if (normalizedEnv !== undefined) return normalizedEnv;
+  }
+
+  const normalizedDefault = tryNormalizeResolvedSettingValue(
+    key,
+    field.defaultValue,
+  );
+  if (normalizedDefault !== undefined) return normalizedDefault;
+
+  if ("fallbackKey" in field && field.fallbackKey) {
+    return getEditableSettingValue(allSettings, field.fallbackKey, env);
+  }
+
+  throw new Error(`Missing valid Config Editor fallback for ${key}`);
+}
 
 export function getEditableSettingValue(
   allSettings: Record<string, string>,
-  key: ConfigKey,
+  key: ConfigEditorKey,
+  env?: Bindings,
 ): string {
-  const value = allSettings[key] ?? CONFIG_FIELDS[key].defaultValue;
-  return key === SETTINGS_KEYS.TIME_ZONE ? normalizeTimeZone(value) : value;
+  const fallbackValue = getEditableSettingFallbackValue(key, env, allSettings);
+  const value = Object.hasOwn(allSettings, key)
+    ? allSettings[key]
+    : fallbackValue;
+  return (
+    tryNormalizeResolvedSettingValue(key, value ?? fallbackValue) ??
+    fallbackValue
+  );
+}
+
+function getEditorConstraints(
+  key: ConfigEditorKey,
+  definition: ConfigEditorDefinition,
+  value: string,
+  fallbackValue: string,
+): Pick<
+  ConfigEditorFieldState,
+  "maxLength" | "min" | "max" | "step" | "options"
+> {
+  switch (definition.type) {
+    case "boolean":
+      return {};
+    case "string":
+      return { maxLength: definition.maxLength };
+    case "number":
+      return {
+        min: definition.min,
+        max: definition.max,
+        step: definition.step,
+      };
+    case "enum":
+      if (definition.options) return { options: definition.options };
+      if (definition.optionsSource === "contentLanguage") {
+        const options = getSupportedLocaleEntries().map((entry) => entry.tag);
+        for (const candidate of [fallbackValue, value]) {
+          if (candidate && !options.includes(candidate))
+            options.push(candidate);
+        }
+        return { options };
+      }
+      if (definition.optionsSource === "timeZone") {
+        const options = getTimeZoneOptions(value).map((entry) => entry.value);
+        for (const candidate of [fallbackValue, value]) {
+          if (candidate && !options.includes(candidate))
+            options.push(candidate);
+        }
+        return { options };
+      }
+      return { options: [value] };
+  }
+}
+
+function buildLinkedConfigEditorField(
+  allSettings: Record<string, string>,
+  env: Bindings,
+  key: ConfigEditorVisibleKey,
+): ConfigEditorFieldState {
+  const field = CONFIG_FIELDS[key];
+  if (!("configEditorLink" in field)) {
+    throw new Error(`Missing Config Editor link metadata for ${key}`);
+  }
+  const definition = field.configEditorLink;
+  const resettable =
+    "resettable" in definition && definition.resettable === true;
+  const modified = Object.hasOwn(allSettings, key);
+  const storedValue = allSettings[key] ?? "";
+
+  if (definition.display === "configured") {
+    const envKeys = "envKeys" in field ? field.envKeys : [];
+    const fallbackRawValue =
+      getEnvString(env, ...envKeys) || field.defaultValue;
+    const effectiveValue = modified ? storedValue : fallbackRawValue;
+    return {
+      key,
+      mode: "link",
+      type: definition.type,
+      value: effectiveValue.trim() ? "true" : "false",
+      fallbackValue: fallbackRawValue.trim() ? "true" : "false",
+      modified,
+      locked: false,
+      settingsPath: definition.settingsPath,
+      display: definition.display,
+      ...(resettable && { resettable: true }),
+    };
+  }
+
+  const fieldEnvKeys = "envKeys" in field ? field.envKeys : [];
+  let fallbackValue: string =
+    ("fallbackValue" in definition ? definition.fallbackValue : undefined) ??
+    getEnvString(env, ...fieldEnvKeys) ??
+    field.defaultValue;
+  if ("fallbackKey" in definition && definition.fallbackKey) {
+    const fallbackField = CONFIG_FIELDS[definition.fallbackKey];
+    const envKeys = "envKeys" in fallbackField ? fallbackField.envKeys : [];
+    fallbackValue = getEnvString(env, ...envKeys) || fallbackField.defaultValue;
+  }
+  const value = storedValue.trim() || fallbackValue;
+
+  return {
+    key,
+    mode: "link",
+    type: definition.type,
+    value: definition.type === "boolean" ? String(value === "true") : value,
+    fallbackValue,
+    modified,
+    locked: false,
+    settingsPath: definition.settingsPath,
+    display: definition.display,
+    ...(resettable && { resettable: true }),
+  };
+}
+
+export function buildConfigEditorFields(
+  allSettings: Record<string, string>,
+  env: Bindings,
+  demoMode: boolean,
+): ConfigEditorFieldState[] {
+  return configEditorVisibleKeys.map((key) => {
+    if ("configEditorLink" in CONFIG_FIELDS[key]) {
+      return buildLinkedConfigEditorField(allSettings, env, key);
+    }
+
+    if (!isEditableSettingKey(key)) {
+      throw new Error(`Missing Config Editor metadata for ${key}`);
+    }
+
+    const definition: ConfigEditorDefinition = CONFIG_FIELDS[key].editor;
+    const fallbackValue = getEditableSettingFallbackValue(
+      key,
+      env,
+      allSettings,
+    );
+    const value =
+      demoMode && key === SETTINGS_KEYS.NOINDEX
+        ? "true"
+        : getEditableSettingValue(allSettings, key, env);
+    const fallbackKey = (CONFIG_FIELDS[key] as { fallbackKey?: "PAGE_SIZE" })
+      .fallbackKey;
+    const base = {
+      key,
+      mode: "edit" as const,
+      type: definition.type,
+      value,
+      fallbackValue,
+      modified: Object.hasOwn(allSettings, key),
+      locked: demoMode && demoLockedSettingKeys.has(key),
+      ...(fallbackKey ? { fallbackKey } : {}),
+    };
+
+    return {
+      ...base,
+      ...getEditorConstraints(key, definition, value, fallbackValue),
+    };
+  });
 }
 
 export function buildEditableSettingsResponse(
   allSettings: Record<string, string>,
   demoMode: boolean,
+  env?: Bindings,
 ): Record<string, string> {
   const result: Record<string, string> = {};
   for (const key of editableSettingKeys) {
-    result[key] = getEditableSettingValue(allSettings, key);
+    result[key] = getEditableSettingValue(allSettings, key, env);
   }
   if (demoMode) {
     result.NOINDEX = "true";
@@ -38,14 +265,14 @@ export function partitionEditableSettingUpdates(
   updates: Record<string, string>,
   demoMode: boolean,
 ): {
-  filteredUpdates: Partial<Record<ConfigKey, string>>;
+  filteredUpdates: Partial<Record<ConfigEditorKey, string>>;
   rejectedKeys: string[];
 } {
-  const filteredUpdates: Partial<Record<ConfigKey, string>> = {};
+  const filteredUpdates: Partial<Record<ConfigEditorKey, string>> = {};
   const rejectedKeys: string[] = [];
 
   for (const [key, value] of Object.entries(updates)) {
-    const configKey = key as ConfigKey;
+    const configKey = key as ConfigEditorKey;
 
     if (
       demoMode &&

package/src/lib/collection-sort.ts

@@ -18,9 +18,9 @@ export function isRatingSortOrder(
 }
 
 /**
- * Returns true when a collection has enough rated posts to make rating sort useful.
+ * Returns true when a collection has enough rated Threads to make rating sort useful.
  *
- * @param ratedPostCount - Number of posts in the collection with a rating
+ * @param ratedThreadCount - Number of Threads with at least one rating
  * @returns Whether rating sort should be shown to readers
  *
  * @example
@@ -28,13 +28,15 @@ export function isRatingSortOrder(
  * supportsCollectionRatingSort(2);
  * ```
  */
-export function supportsCollectionRatingSort(ratedPostCount: number): boolean {
-  return ratedPostCount > 1;
+export function supportsCollectionRatingSort(
+  ratedThreadCount: number,
+): boolean {
+  return ratedThreadCount > 1;
 }
 
 /**
  * Resolves the sort order for a collection page, falling back when rating
- * sorting is requested but the collection does not have enough rated posts.
+ * sorting is requested but the collection does not have enough rated Threads.
  *
  * @param requestedSort - Sort order from the request query
  * @param defaultSort - Collection default sort order

package/src/lib/constants.ts

@@ -22,12 +22,14 @@ export const RESERVED_PATHS = [
   "reset",
   "collections",
   "compose",
+  "preview",
   "new",
   "static",
   "assets",
   "_assets",
   "healthz",
   "readyz",
+  "skill.md",
 ] as const;
 
 export type ReservedPath = (typeof RESERVED_PATHS)[number];

package/src/lib/feed-path.ts

@@ -0,0 +1,25 @@
+const NON_FEED_PATH_PREFIXES = ["/api", "/settings", "/compose", "/_"];
+
+function hasPathPrefix(path: string, prefix: string): boolean {
+  return path === prefix || path.startsWith(`${prefix}/`);
+}
+
+/**
+ * Check whether an internal application path is an Atom feed endpoint.
+ *
+ * @param path - Request pathname after any configured site prefix is removed
+ * @returns Whether the path is a canonical or legacy feed URL
+ * @example
+ * ```ts
+ * isRssFeedPath("/reading/feed"); // true
+ * isRssFeedPath("/api/posts"); // false
+ * ```
+ */
+export function isRssFeedPath(path: string): boolean {
+  if (path === "/feed" || path.startsWith("/feed/")) return true;
+  if (NON_FEED_PATH_PREFIXES.some((prefix) => hasPathPrefix(path, prefix))) {
+    return false;
+  }
+
+  return path.endsWith("/feed") || path.endsWith("/feed/atom.xml");
+}