smoodly 0.0.17 → 0.0.19

package/dist/fields.js

@@ -107,6 +107,9 @@ export const f = {
     radio: (options) => builder({ type: "radio", options: normalizeOptions(options) }),
     /** Several values from a list, stored as an array, shown as a checkbox list. */
     checkboxes: (options) => builder({ type: "checkboxes", options: normalizeOptions(options) }),
+    /** Short labels edited as chips, stored as a string array: trimmed, no
+     *  case-insensitive duplicates (spec 2026-09-17 §4). `.min`/`.max` count tags. */
+    tags: () => builder({ type: "tags" }),
     object: (shape) => {
         for (const [k, v] of Object.entries(shape))
             assertContainerItem("f.object", v.descriptor, k);
@@ -124,6 +127,8 @@ export const f = {
         const nested = findMatch(d, (sub) => sub.type === "list");
         if (nested !== null)
             throw new Error(`smoodly: f.list cannot hold another list (at ${describePath(nested)}) — nested lists are not supported.`);
+        if (d.type === "tags")
+            throw new Error("smoodly: f.list cannot hold f.tags() — a list of tag lists is a nested list; put the tags in an object item.");
         assertContainerItem("f.list", d);
         return builder({ type: "list", item: d });
     },

package/dist/index.d.ts

@@ -7,7 +7,7 @@ import { entryPage } from "./entry-page.tsx";
 import { globalItem } from "./global.ts";
 import { marks } from "./marks.ts";
 export { Zone, renderPage, EMPTY_PAGE_CONTEXT } from "./render.tsx";
-export type { PageTree, TreeNode, ZoneContent, PairedPage, Registry, PageContext, PageContextLink, PageLink, PageViewProps } from "./render.tsx";
+export type { PageTree, TreeNode, ZoneContent, PairedPage, Registry, PageContext, PageContextLink, PageContextAlternate, PageLink, PageViewProps } from "./render.tsx";
 export { RichText, defaultRichTextImage } from "./richtext-render.tsx";
 export type { RichTextProps, RichTextElement, RichTextImageProps } from "./richtext-render.tsx";
 export type { PageSchema } from "./page.ts";
@@ -21,6 +21,7 @@ export * from "./custom/index.ts";
 export type { Condition, ConditionOp, ConditionScope } from "./conditions.ts";
 export { defaultsOf, withDefaults } from "./field-defaults.ts";
 export { filterPageTree } from "./page-tree.ts";
+export { DEFAULT_ADMIN_PATH } from "./admin-path.ts";
 export { ASSET_COLLECTION, DEFAULT_MEDIA, MEDIA_TYPES, FULL_CROP, CENTER_HOTSPOT, parseAspect, cropAspect, clamp01, isMediaValue, collectAssetIds, applyAssets, } from "./media.ts";
 export type { Crop, Hotspot, AssetKind, ImageValue, VideoValue, FileValue, AssetMeta, AssetRecord, ResolvedImage, ResolvedVideo, ResolvedFile, } from "./media.ts";
 export { z } from "./zones.ts";
@@ -48,8 +49,8 @@ export { affectedTargets, pageTag, entryTag, globalTag, pagesTreeTag, collection
 export type { AffectedTargets } from "./revalidate.ts";
 export { resolveTree, resolveFields, resolveMedia } from "./resolve.ts";
 export type { EntryFetcher, ResolveFieldsOptions, AssetFetcher } from "./resolve.ts";
-export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, } from "./paths.ts";
-export type { LocaleSet, PathTarget, PathRow, PageLike, EntryLike, PageTreeNode, PagePathOptions } from "./paths.ts";
+export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, pageAlternates, entryAlternates, } from "./paths.ts";
+export type { LocaleSet, PathTarget, PathRow, PageLike, EntryLike, PageTreeNode, PagePathOptions, LocaleAlternate, PageAlternate } from "./paths.ts";
 export { fixedPathFor } from "./localize.ts";
 export type { PageStore, PageRecord, PageLocale, PageVersion, PageStoreOptions, CreatePageInput, AddLocaleOptions } from "./store.ts";
 export { pathOptions, pageErrors, localeRow, pageRefEdges, DEFAULT_LOCALES } from "./store.ts";

package/dist/index.js

@@ -16,6 +16,7 @@ export { DEFAULT_STYLE_VALUES, STYLE_KEYS, SPACING_NONE, resolveStyleValues, sty
 export * from "./custom/index.js";
 export { defaultsOf, withDefaults } from "./field-defaults.js";
 export { filterPageTree } from "./page-tree.js";
+export { DEFAULT_ADMIN_PATH } from "./admin-path.js";
 export { ASSET_COLLECTION, DEFAULT_MEDIA, MEDIA_TYPES, FULL_CROP, CENTER_HOTSPOT, parseAspect, cropAspect, clamp01, isMediaValue, collectAssetIds, applyAssets, } from "./media.js";
 export { z } from "./zones.js";
 export { defineConfig } from "./config.js";
@@ -35,7 +36,7 @@ export { SupabasePathIndex } from "./supabase-path-index.js";
 export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES, localizedKeys, splitFields, entryLocaleRow, entryFieldsIn, entryRefEdges, entryTitleIn, matchesWhere, } from "./entry-store.js";
 export { affectedTargets, pageTag, entryTag, globalTag, pagesTreeTag, collectionTag } from "./revalidate.js";
 export { resolveTree, resolveFields, resolveMedia } from "./resolve.js";
-export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, } from "./paths.js";
+export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, pageAlternates, entryAlternates, } from "./paths.js";
 export { fixedPathFor } from "./localize.js";
 export { pathOptions, pageErrors, localeRow, pageRefEdges, DEFAULT_LOCALES } from "./store.js";
 export { DEFAULT_TOOLSET } from "./toolset.js";

package/dist/next/page-renderer.js

@@ -34,7 +34,7 @@ export function createPageRenderer(options) {
                 console.warn(`smoodly: no page registration named "${hit.template}" — the record at ${hit.path} is a 404.`);
                 notFound();
             }
-            const page = pageContextOf(hit, (path) => href(path, locale));
+            const page = pageContextOf(hit, href);
             return renderPage(Page, hit.tree, { sections: options.sections, elements: options.elements, styles: site.styles, custom: site.custom }, { editor, page });
         }
         const View = entryPages.get(hit.collection);
@@ -42,12 +42,16 @@ export function createPageRenderer(options) {
             console.warn(`smoodly: no entry page for collection "${hit.collection}" — the entry at ${hit.path} is a 404.`);
             notFound();
         }
-        return _jsx(View, { entry: hit.entry, path: hit.path });
+        return _jsx(View, { entry: hit.entry, path: hit.path, locale: hit.locale, locales: hit.locales });
     }
+    /** hreflang from the SAME map a language switch reads (spec 2026-09-15 §3): the locales with a URL, through href. */
     function alternates(hit) {
         if (site.locales.supported.length < 2)
             return {};
-        const languages = Object.fromEntries(Object.entries(hit.paths).map(([locale, path]) => [locale, href(path, locale)]));
+        const languages = {};
+        for (const [locale, alt] of Object.entries(hit.locales))
+            if (alt?.path)
+                languages[locale] = href(alt.path, locale);
         return { alternates: { languages } };
     }
     async function page(pathFor, opts, accept) {

package/dist/page.js

@@ -1,6 +1,6 @@
 import { describePath, findMatch } from "./fields.js";
 /** What a page field may be: a settings form, never a ref, a list or a document (spec 2026-09-10 page fields §1). */
-const PAGE_FIELD_TYPES = new Set(["text", "link", "date", "number", "boolean", "select", "radio", "checkboxes", "image", "video", "file", "object"]);
+const PAGE_FIELD_TYPES = new Set(["text", "link", "date", "number", "boolean", "select", "radio", "checkboxes", "tags", "image", "video", "file", "object"]);
 /** The descriptor at a dotted path below `d` (object subfields only — page fields hold no lists). */
 function descriptorAt(d, path) {
     let cur = d;

package/dist/paths.d.ts

@@ -91,6 +91,27 @@ export declare function entrySegment(entry: EntryLike, locale: string): string |
 export declare function entryPathRows(targets: EntryLike[], byId: (id: string) => EntryLike | undefined, collection: {
     path?: string | Record<string, string>;
 }, set: LocaleSet): PathRow[];
+/** A target's address in one locale (spec 2026-09-15 §1). A page always
+ *  has both; an entry's slug is null when its row claims no URL, and its
+ *  path null then or when the collection has no `path`. */
+export type LocaleAlternate = {
+    slug: string | null;
+    path: string | null;
+};
+export type PageAlternate = {
+    slug: string;
+    path: string;
+};
+/** The page's address in EVERY supported locale, in config order: null
+ *  where the node is absent, where an ancestor is, or where `advertised`
+ *  says no — the site passes "published, or draft mode", so an
+ *  unpublished translation is never linked on the public site. */
+export declare function pageAlternates(node: PageLike, byId: (id: string) => PageLike | undefined, opts: PagePathOptions, advertised: (locale: string) => boolean): Record<string, PageAlternate | null>;
+/** The entry's address in EVERY supported locale, in config order: null
+ *  where the row is absent or not advertised. `pathIn` is the caller's
+ *  path source — the derived rows in a list, the `paths` index for one
+ *  loaded record — so both entry reads apply ONE rule. */
+export declare function entryAlternates(entry: EntryLike, set: LocaleSet, advertised: (locale: string) => boolean, pathIn: (locale: string) => string | null): Record<string, LocaleAlternate | null>;
 export type PageTreeNode<T extends PageLike> = {
     record: T;
     path: string | null;

package/dist/paths.js

@@ -130,6 +130,31 @@ export function entryPathRows(targets, byId, collection, set) {
     }
     return rows;
 }
+/** The page's address in EVERY supported locale, in config order: null
+ *  where the node is absent, where an ancestor is, or where `advertised`
+ *  says no — the site passes "published, or draft mode", so an
+ *  unpublished translation is never linked on the public site. */
+export function pageAlternates(node, byId, opts, advertised) {
+    const out = {};
+    for (const locale of opts.locales.supported) {
+        const own = node.locales[locale];
+        const path = own && advertised(locale) ? pagePathIn(node, byId, locale, opts) : null;
+        out[locale] = own && path !== null ? { slug: own.slug, path } : null;
+    }
+    return out;
+}
+/** The entry's address in EVERY supported locale, in config order: null
+ *  where the row is absent or not advertised. `pathIn` is the caller's
+ *  path source — the derived rows in a list, the `paths` index for one
+ *  loaded record — so both entry reads apply ONE rule. */
+export function entryAlternates(entry, set, advertised, pathIn) {
+    const out = {};
+    for (const locale of set.supported) {
+        const own = entry.locales[locale];
+        out[locale] = own && advertised(locale) ? { slug: own.slug, path: pathIn(locale) } : null;
+    }
+    return out;
+}
 export function buildPageTree(records, locale, opts) {
     const byId = (id) => records.find((r) => r.id === id);
     const build = (parentId) => records

package/dist/render.d.ts

@@ -1,4 +1,5 @@
 import type { ComponentType, ReactElement } from "react";
+import type { PageAlternate } from "./paths.ts";
 import type { PageSchema } from "./page.ts";
 import type { BuilderMap, NamespaceValues } from "./schema.ts";
 import { type StyleValues } from "./styles.ts";
@@ -41,16 +42,25 @@ export type PageLink = {
 export type PageContextLink = PageLink & {
     url: string;
 };
+/** The page's address in one other locale, `url` through the app's href seam (spec 2026-09-15 §3). */
+export type PageContextAlternate = PageAlternate & {
+    url: string;
+};
 export type PageContext<Fields = Record<string, unknown>> = {
     id: string;
     title: string;
     path: string;
     url: string;
+    /** The locale the page was rendered in. */
+    locale: string;
     /** The page's own fields, typed from its schema on the view; resolved, defaults applied. */
     fields: Fields;
     /** Root first, parent last. */
     ancestors: ReadonlyArray<PageContextLink>;
     children: ReadonlyArray<PageContextLink>;
+    /** One key per supported locale: the page's `{ slug, path, url }` there, or null where it is
+     *  absent or unpublished (draft mode: absent only). What a language switch links to. */
+    locales: Readonly<Record<string, PageContextAlternate | null>>;
 };
 /** The `page` prop of a view rendered outside the site (a test, a preview
  *  of a shape): a real object, so a view never guards an optional prop, but

package/dist/render.js

@@ -8,7 +8,8 @@ import { CUSTOM_NODE_TYPE, createCustomSection } from "./custom/index.js";
  *  no position in the tree. Frozen: one singleton shared by every such
  *  render, so a view that pushed onto it would leak into the next. */
 export const EMPTY_PAGE_CONTEXT = Object.freeze({
-    id: "", title: "", path: "/", url: "/", fields: Object.freeze({}), ancestors: Object.freeze([]), children: Object.freeze([]),
+    id: "", title: "", path: "/", url: "/", locale: "", fields: Object.freeze({}), ancestors: Object.freeze([]), children: Object.freeze([]),
+    locales: Object.freeze({}),
 });
 export function Zone({ of: content }) {
     // A malformed tree (bad data, a client that skipped isPageTree) must not

package/dist/site.d.ts

@@ -2,7 +2,7 @@ import type { AssetStore } from "./asset-store.ts";
 import type { CollectionSchema, EntryOrder } from "./collections.ts";
 import type { Descriptor } from "./fields.ts";
 import { type EntryRecord, type EntryStore, type Where } from "./entry-store.ts";
-import { type LocaleSet, type PathTarget } from "./paths.ts";
+import { type LocaleAlternate, type LocaleSet, type PageAlternate, type PathTarget } from "./paths.ts";
 import type { SectionLike } from "./refs.ts";
 import type { PageContext, PageLink, PageTree } from "./render.tsx";
 import { type GlobalSchema } from "./global.ts";
@@ -39,6 +39,8 @@ export type SitePageSchema = {
 };
 export type SitePage = {
     kind: "page";
+    /** The locale the hit was loaded in. */
+    locale: string;
     record: PageRecord;
     template: string;
     tree: PageTree;
@@ -48,20 +50,21 @@ export type SitePage = {
     fields: Record<string, unknown>;
     ancestors: PageLink[];
     children: PageLink[];
-    /** locale → path, for metadata alternates: the locales the page is
-     *  PUBLISHED in, since that is what may be advertised — draft mode
-     *  carries every locale the page exists in. */
-    paths: Record<string, string>;
+    /** One key per supported locale: the page's `{ slug, path }` there, or null where it is
+     *  absent or, outside draft mode, unpublished (spec 2026-09-15 §1). */
+    locales: Record<string, PageAlternate | null>;
 };
 export type SiteEntry = {
     kind: "entry";
+    /** The locale the hit was loaded in. */
+    locale: string;
     collection: string;
     /** `fields` are the locale's MERGED fields — shared + localized + slug —
      *  with refs resolved: the published snapshot on the public path, the
      *  live row in draft mode. */
     entry: EntryRecord;
     path: string;
-    paths: Record<string, string>;
+    locales: Record<string, LocaleAlternate | null>;
 };
 export type SiteHit = SitePage | SiteEntry;
 export type PageTreeItem = {
@@ -75,6 +78,8 @@ export type PageTreeItem = {
 export type SiteEntryItem = {
     entry: EntryRecord;
     path: string | null;
+    locale: string;
+    locales: Record<string, LocaleAlternate | null>;
 };
 export type EntryTreeItem = SiteEntryItem & {
     children: EntryTreeItem[];
@@ -131,7 +136,7 @@ export interface SmoodlySite {
         draft?: boolean;
     }): Promise<V | null>;
 }
-/** The `page` prop for a loaded page. `toUrl` is the app's `href` seam
- *  bound to the render locale; the default keeps CMS paths as URLs. */
-export declare function pageContextOf(hit: SitePage, toUrl?: (path: string) => string): PageContext;
+/** The `page` prop for a loaded page. `href` is the app's seam from a
+ *  locale-relative path to a site URL; the default keeps CMS paths as URLs. */
+export declare function pageContextOf(hit: SitePage, href?: (path: string, locale: string) => string): PageContext;
 export declare function createSmoodlySite(options: SiteOptions): SmoodlySite;

package/dist/site.js

@@ -1,5 +1,5 @@
 import { ARRAY_FIELD_TYPES, entryFieldsIn, localizedKeys, schemaOf } from "./entry-store.js";
-import { buildPageTree, chainOf, entryPathRows, entrySegment, pagePath, } from "./paths.js";
+import { buildPageTree, chainOf, entryAlternates, entryPathRows, entrySegment, pageAlternates, pagePath, } from "./paths.js";
 import { resolveFields, resolveMedia, resolveMediaSets, resolveTree } from "./resolve.js";
 import { elementSchemas } from "./richtext-walk.js";
 import { globalNodeId, SETTINGS_KEY, STYLES_KEY, CSS_KEY } from "./global.js";
@@ -7,18 +7,20 @@ import { SMD_KEY } from "./section-wrapper.js";
 import { resolveStyleValues } from "./styles.js";
 import { resolveCustom } from "./custom/index.js";
 import { withDefaults } from "./field-defaults.js";
-/** The `page` prop for a loaded page. `toUrl` is the app's `href` seam
- *  bound to the render locale; the default keeps CMS paths as URLs. */
-export function pageContextOf(hit, toUrl = (p) => p) {
-    const withUrl = (l) => ({ ...l, url: toUrl(l.path) });
+/** The `page` prop for a loaded page. `href` is the app's seam from a
+ *  locale-relative path to a site URL; the default keeps CMS paths as URLs. */
+export function pageContextOf(hit, href = (p) => p) {
+    const withUrl = (l) => ({ ...l, url: href(l.path, hit.locale) });
     return {
         id: hit.record.id,
         title: hit.title,
         path: hit.path,
-        url: toUrl(hit.path),
+        url: href(hit.path, hit.locale),
+        locale: hit.locale,
         fields: hit.fields,
         ancestors: hit.ancestors.map(withUrl),
         children: hit.children.map(withUrl),
+        locales: Object.fromEntries(Object.entries(hit.locales).map(([code, alt]) => [code, alt && { ...alt, url: href(alt.path, code) }])),
     };
 }
 export function createSmoodlySite(options) {
@@ -128,10 +130,12 @@ export function createSmoodlySite(options) {
         const fields = await linkFields([...chain.slice(0, -1), ...kids], locale, draft);
         const ancestors = chain.slice(0, -1).map((n) => link(n, byId, locale, draft, fields));
         const children = kids.map((n) => link(n, byId, locale, draft, fields));
-        // Alternates advertise PUBLISHED locales only; the editor (draft) sees every present one.
-        const paths = Object.fromEntries(Object.entries(await pages.pathsOf(id)).filter(([l]) => draft || record.locales[l]?.status === "published"));
+        // Alternates advertise PUBLISHED locales only; the editor (draft) sees every present
+        // one. Derived from the tree already listed — no index lookup (spec 2026-09-15 §2).
+        const alternates = pageAlternates(record, byId, pathOpts, (l) => draft || record.locales[l]?.status === "published");
         return {
             kind: "page",
+            locale,
             record,
             template: record.template,
             tree,
@@ -140,7 +144,7 @@ export function createSmoodlySite(options) {
             fields: withDefaults(tree.fields, pageFields(record.template)),
             ancestors,
             children,
-            paths,
+            locales: alternates,
         };
     }
     async function loadEntry(id, locale, path, draft) {
@@ -162,8 +166,11 @@ export function createSmoodlySite(options) {
                 return null;
             const fields = await resolveFields(raw, schema.fields, { collections: options.collections, elements: options.elements, fetch: fetcher(draft, locale), assets: assetFetcher() });
             // Alternates advertise PUBLISHED locales only; the editor (draft) sees every present one.
-            const paths = Object.fromEntries(Object.entries(await entries.pathsOf(schema.name, id)).filter(([l]) => draft || record.locales[l]?.status === "published"));
-            return { kind: "entry", collection: schema.name, entry: { ...record, fields }, path, paths };
+            // One record is in memory (a nested entry's parents are not), so the `paths` index
+            // supplies the paths — the same single lookup as before (spec 2026-09-15 §2).
+            const known = await entries.pathsOf(schema.name, id);
+            const alternates = entryAlternates(record, locales, (l) => draft || record.locales[l]?.status === "published", (l) => known[l] ?? null);
+            return { kind: "entry", locale, collection: schema.name, entry: { ...record, fields }, path, locales: alternates };
         }
         return null;
     }
@@ -171,15 +178,21 @@ export function createSmoodlySite(options) {
     /** One locale's published fields and path for entries of one collection;
      *  `all` is the whole collection (a draft ancestor still contributes
      *  its segment). `fieldsById` is the published read for the locale. */
-    function entryItems(schema, wanted, all, locale, fieldsById) {
+    function entryItems(schema, wanted, all, locale, draft, fieldsById) {
         const index = new Map(all.map((e) => [e.id, e]));
         const byId = (x) => index.get(x);
         return wanted
             .filter((record) => fieldsById[record.id] !== undefined)
-            .map((record) => ({
-            entry: { ...record, fields: fieldsById[record.id] },
-            path: entryPathRows([record], byId, schema, locales).find((r) => r.locale === locale)?.path ?? null,
-        }));
+            .map((record) => {
+            const rows = entryPathRows([record], byId, schema, locales);
+            const pathIn = (l) => rows.find((r) => r.locale === l)?.path ?? null;
+            return {
+                entry: { ...record, fields: fieldsById[record.id] },
+                path: pathIn(locale),
+                locale,
+                locales: entryAlternates(record, locales, (l) => draft || record.locales[l]?.status === "published", pathIn),
+            };
+        });
     }
     async function getEntries(collection, o = {}) {
         const schema = schemaOf(options.collections, collection);
@@ -220,7 +233,7 @@ export function createSmoodlySite(options) {
         const fetchAssets = assetFetcher();
         if (fetchAssets)
             await resolveMediaSets(Object.values(fieldsById).map((values) => ({ values, descriptors: schema.fields })), fetchAssets, elements);
-        return entryItems(schema, inLocale, all, locale, fieldsById);
+        return entryItems(schema, inLocale, all, locale, draft, fieldsById);
     }
     const api = {
         async getPagesTree(o) {
@@ -257,7 +270,7 @@ export function createSmoodlySite(options) {
             const locale = localeOf(o);
             if (idOrPath.startsWith("/")) {
                 const hit = await site.resolve(locale, idOrPath, { draft: o?.draft ?? false });
-                return hit?.kind === "entry" && hit.collection === collection ? { entry: hit.entry, path: hit.path } : null;
+                return hit?.kind === "entry" && hit.collection === collection ? { entry: hit.entry, path: hit.path, locale: hit.locale, locales: hit.locales } : null;
             }
             const items = await getEntries(collection, { locale, draft: o?.draft ?? false });
             const byId = items.find((i) => i.entry.id === idOrPath);

package/dist/supabase-entry-store.js

@@ -365,7 +365,7 @@ export class SupabaseEntryStore {
         }
         for (const [key, want] of Object.entries(options?.where ?? {})) {
             // Any-of compares the text form (`->>`). A scalar is JSONB containment;
-            // an array-valued field (checkboxes, refList, list) contains `[value]`,
+            // an array-valued field (checkboxes, refList, list, tags) contains `[value]`,
             // a scalar field `value` — the memory adapter's matchesWhere agrees.
             if (Array.isArray(want)) {
                 query = query.in(`fields->>${key}`, want.map(String));

package/dist/tags.d.ts

@@ -0,0 +1,19 @@
+/** Trimmed, inner whitespace runs collapsed to one space. */
+export declare const normalizeTag: (s: string) => string;
+/** Tags are one tag when they differ only in case. */
+export declare const sameTag: (a: string, b: string) => boolean;
+/** Commit typed or pasted text: split on commas, normalize, drop empties and
+ *  duplicates of what is already there, stop at `max`. A part that matches a
+ *  `known` tag takes its casing. `duplicate` is the existing tag the first
+ *  dropped part hit, so the widget can flash that chip. */
+export declare function addTags(current: readonly string[], input: string, opts?: {
+    max?: number;
+    known?: readonly string[];
+}): {
+    tags: string[];
+    duplicate: string | null;
+};
+/** Every tag in a set of field values (each a tag array, or anything else), sorted. Where
+ *  entries disagree on a tag's casing the most used one wins, a tie going to plain string
+ *  order — never to the order the values arrived in, which is the store's business. */
+export declare function distinctTags(values: readonly unknown[]): string[];

package/dist/tags.js

@@ -0,0 +1,50 @@
+// The rules of an f.tags() value (spec 2026-09-17 §4) as pure functions:
+// the chip widget, the validator and the suggestions op all go through
+// these, so a tag means the same thing on every side.
+/** Trimmed, inner whitespace runs collapsed to one space. */
+export const normalizeTag = (s) => s.trim().replace(/\s+/g, " ");
+const fold = (s) => s.toLocaleLowerCase();
+/** Tags are one tag when they differ only in case. */
+export const sameTag = (a, b) => fold(a) === fold(b);
+/** Commit typed or pasted text: split on commas, normalize, drop empties and
+ *  duplicates of what is already there, stop at `max`. A part that matches a
+ *  `known` tag takes its casing. `duplicate` is the existing tag the first
+ *  dropped part hit, so the widget can flash that chip. */
+export function addTags(current, input, opts = {}) {
+    const tags = [...current];
+    let duplicate = null;
+    for (const part of input.split(",")) {
+        const typed = normalizeTag(part);
+        if (typed === "")
+            continue;
+        const tag = opts.known?.find((k) => sameTag(k, typed)) ?? typed;
+        const hit = tags.find((t) => sameTag(t, tag));
+        if (hit !== undefined) {
+            duplicate ?? (duplicate = hit);
+            continue;
+        }
+        if (typeof opts.max === "number" && tags.length >= opts.max)
+            break;
+        tags.push(tag);
+    }
+    return { tags, duplicate };
+}
+/** Every tag in a set of field values (each a tag array, or anything else), sorted. Where
+ *  entries disagree on a tag's casing the most used one wins, a tie going to plain string
+ *  order — never to the order the values arrived in, which is the store's business. */
+export function distinctTags(values) {
+    const variants = new Map();
+    for (const value of values) {
+        if (!Array.isArray(value))
+            continue;
+        for (const tag of value) {
+            if (typeof tag !== "string" || tag === "")
+                continue;
+            const counts = variants.get(fold(tag)) ?? new Map();
+            counts.set(tag, (counts.get(tag) ?? 0) + 1);
+            variants.set(fold(tag), counts);
+        }
+    }
+    const pick = (counts) => [...counts].sort(([a, n], [b, m]) => m - n || (a < b ? -1 : 1))[0][0];
+    return [...variants.values()].map(pick).sort((a, b) => a.localeCompare(b, undefined, { sensitivity: "base" }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoodly",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "Open-source, code-first CMS for Next.js on Supabase: define a component once, it becomes a typed, editable building block.",
   "license": "MIT",
   "repository": {