create-ailk 0.31.0 → 0.33.0

package/dist/language-import.js

@@ -88,7 +88,7 @@ function entriesOf(section) {
             if (!str(raw["question"]) || !str(raw["answer"]))
                 return undefined;
             entries.push({
-                key: raw["question"],
+                key: JSON.stringify([raw["question"], raw["answer"]]),
                 words: { question: raw["question"], answer: raw["answer"] },
                 kicker: raw["kicker"] !== undefined,
             });
@@ -113,12 +113,13 @@ export function withLanguage(adapters, options) {
     let state = "unprobed";
     let offStatus;
     const items = new Map();
-    /** In-run FAQ slug claims, so two questions never share a slug (D2); a term's slug is its key. */
+    /** In-run FAQ slug claims, so two items never share a slug (D2, #10778 D2); a term's slug is its key. */
     const claimed = new Map();
     const occurrences = [];
     const homes = [];
     const kickers = [];
     const displaced = [];
+    const collisions = [];
     async function call(method, url, body) {
         for (let retry = 0;; retry++) {
             let response;
@@ -208,9 +209,11 @@ export function withLanguage(adapters, options) {
                 throw new Error(`language: ${kind}/${known.slug}: ${known.failed}`);
             if (home && !known.winner.home) {
                 // D3 — the home page outranks a page read before it; an item this run
-                // created takes its words, and a found one is never written (D4).
+                // created takes its words unless they are already its own (#10778 D4),
+                // and a found one is never written (D4).
+                const rewords = known.created && options.apply && !same(known.winner.words, entry.words);
                 known.winner = { page, words: entry.words, home: true };
-                if (known.created && options.apply)
+                if (rewords)
                     await write(known, entry.words, known.version ?? null);
             }
             return known;
@@ -221,15 +224,22 @@ export function withLanguage(adapters, options) {
             stored = await read(kind, slug);
         }
         else {
-            const first = faqSlug(entry.key);
+            const question = entry.words["question"];
+            const first = faqSlug(question);
             let skipped;
+            let collided;
             for (let n = 1;; n++) {
                 const candidate = n === 1 ? first : `${first}-${n}`;
+                // Claimed in this run by another pair: the same question answered otherwise
+                // is a collision (#10778 D2), another question that slugs alike is not.
                 const holder = claimed.get(candidate);
-                if (holder !== undefined && holder !== entry.key)
+                if (holder !== undefined) {
+                    if (holder.winner.words["question"] === question)
+                        collided ??= { slug: candidate, from: holder.winner.page };
                     continue;
+                }
                 stored = await read(kind, candidate);
-                if (stored !== null && stored.words["question"] !== entry.key) {
+                if (stored !== null && stored.words["question"] !== question) {
                     skipped ??= candidate;
                     continue;
                 }
@@ -238,9 +248,9 @@ export function withLanguage(adapters, options) {
             }
             if (skipped !== undefined)
                 displaced.push({ slug: skipped, next: slug });
+            if (collided !== undefined)
+                collisions.push({ ...collided, page, next: slug });
         }
-        if (kind === "faq")
-            claimed.set(slug, entry.key);
         const item = {
             kind,
             slug,
@@ -249,6 +259,8 @@ export function withLanguage(adapters, options) {
             ...(stored !== null && { stored }),
         };
         items.set(mapKey, item);
+        if (kind === "faq")
+            claimed.set(slug, item);
         if (stored === null)
             await write(item, entry.words, null);
         return item;
@@ -355,7 +367,9 @@ export function withLanguage(adapters, options) {
                 const key = `${PREFIX[item.kind]}${item.slug}`;
                 const live = item.created || item.stored.live;
                 if (item.kind === home.kind && item.failed === undefined && live && !home.shown.has(key)) {
-                    topUps.push({ kind: item.kind, slug: item.slug, page: `/${home.slug}` });
+                    const shown = item.created ? item.winner.words : (item.stored.published ?? {});
+                    const name = shown[item.kind === "faq" ? "question" : "term"] ?? "";
+                    topUps.push({ kind: item.kind, slug: item.slug, page: `/${home.slug}`, name });
                 }
             }
         }
@@ -371,6 +385,7 @@ export function withLanguage(adapters, options) {
             topUps,
             droppedKickers: kickers,
             displaced,
+            collisions,
         };
     }
     return {
@@ -421,13 +436,14 @@ export function languageCountsLine(result, apply) {
     const { created, unchanged, kept, failed } = result.counts;
     return `language: ${apply ? "created" : "create"} ${created} · unchanged ${unchanged} · kept ${kept} · failed ${failed}`;
 }
-/** Every line D7 prints, in order: items, counts, render changes, top-ups, dropped kickers, displacements. */
+/** Every line D7 prints, in order: items, counts, render changes, collisions, top-ups, dropped kickers, displacements. */
 export function languageLines(result, apply) {
     const verb = (r) => (!apply && r === "created" ? "create" : r);
     return [
         ...result.items.map((i) => `language: ${i.kind}/${i.slug}: ${verb(i.result)}${i.reason === undefined ? "" : ` — ${i.reason}`}`),
         languageCountsLine(result, apply),
         ...result.renderChanges.map(renderChangeLine),
+        ...result.collisions.map((c) => `language: faq/${c.slug} on ${c.page}: not merged — ${c.from} answers the same question otherwise; ${c.page} pins faq/${c.next}`),
         ...result.topUps.map((t) => `language: ${t.kind}/${t.slug}: now also on ${t.page}`),
         ...result.droppedKickers.map((k) => `language: faq/${k.slug}: kicker dropped`),
         ...result.displaced.map((d) => `language: faq/${d.slug}: the workspace holds a different question here; the file's is ${d.next}`),

package/dist/lib/import-mdx.d.ts

@@ -32,6 +32,19 @@ export interface MdxAdapterModule {
         data: Record<string, unknown>;
         content: string;
     };
+    /**
+     * The site-field rule from the adapter's validation package (#10806 D4);
+     * without it the editorial walk sends no `siteFields` and no `tags`, and
+     * names the keys it would have sent.
+     */
+    siteFields?: SiteFieldRules;
+}
+/** The validation package's site-field rule, typed structurally. */
+export interface SiteFieldRules {
+    refusal: (key: string, value: unknown) => string | null;
+    publicPageTags: (tags: readonly unknown[]) => string[];
+    maxKeys: number;
+    maxBytes: number;
 }
 export interface ImportMdxOptions {
     /** The site's content root (`content/`). */
@@ -88,6 +101,35 @@ interface At {
 export declare function outcomePath(at: At): string;
 /** The whole report, one line per page and a final count line. */
 export declare function formatImportMdxReport(result: ImportMdxResult): string;
+/**
+ * A section string's inline HTML as the constrained Markdown the upstream
+ * renderers read (#10804 D3): a link with an allowed href becomes
+ * `[label](href)`, `<br>` a newline, a block or list item a paragraph break,
+ * and every other tag goes, its text kept. A string with no tag comes back
+ * byte-identical; the result never holds one. `notCarried` names, sorted,
+ * every tag the layout does not keep.
+ */
+export declare function inlineHtmlToMarkdown(value: string): {
+    text: string;
+    notCarried: string[];
+};
+/**
+ * Each section with every string in its `data` that holds a tag converted by
+ * `inlineHtmlToMarkdown` (#10804 D2); keys and tag-free strings are kept as
+ * they are. `notCarried` is the sorted union of the names it did not carry.
+ */
+export declare function sectionsWithoutHtml<T>(sections: readonly T[]): {
+    sections: T[];
+    notCarried: string[];
+};
+/**
+ * The first section-string or key rule of the hub's structure write
+ * (`checkSectionData`) the layout breaks, as `<message> (sections[i].data<path>)`,
+ * or `undefined` (#10804 D5). The depth and size bounds are not restated.
+ */
+export declare function layoutRefusal(layout: {
+    sections: readonly unknown[];
+}): string | undefined;
 export declare function importMdx(opts: ImportMdxOptions): Promise<ImportMdxResult>;
 /**
  * The site's installed adapter package, resolved from its `apps/web` — never