smoodly 0.0.58 → 0.0.59

package/dist/entry-store.d.ts

@@ -7,6 +7,8 @@ import { type LocaleSet } from "./paths.ts";
 export type EntryLocale = {
     /** The entry's segment in this locale; null claims no URL. */
     slug: string | null;
+    /** The entry's place in a manual order as this locale lists it; null sorts last (2026-11-13). */
+    sort: number | null;
     status: "draft" | "published";
     /** ONLY the .localized() fields, for this locale. */
     fields: Record<string, unknown>;
@@ -29,7 +31,6 @@ export type EntryRecord = {
     fields: Record<string, unknown>;
     /** Only the locales present. Presence IS the row. */
     locales: Record<string, EntryLocale>;
-    sort: number | null;
     createdAt: number;
     updatedAt: number;
 };
@@ -83,6 +84,25 @@ export type ListOptions = {
      */
     parent?: string | null;
 };
+/** The admin's list of a collection, a page at a time (2026-11-13): every entry of the collection, present in
+ *  `locale` or not, in the collection's order as `locale` lists it. */
+export type EntryPageQuery = {
+    locale: string;
+    /** How many entries, and how many to skip first. */
+    limit: number;
+    offset?: number;
+    /** Only entries whose title field holds this text, in the shared fields or in any locale's; matched without
+     *  regard to ASCII case. Ignored for a collection with no `titleField`, and when empty. */
+    search?: string;
+};
+/** `total` counts every entry the query matches, before `limit` and `offset`. */
+export type EntryPage = {
+    entries: EntryRecord[];
+    total: number;
+};
+/** Whether an entry's title field holds `search`, in the shared fields or any locale row's (the memory store's
+ *  reading; the SQLite store says the same in SQL). */
+export declare function matchesSearch(record: EntryRecord, titleField: string, search: string): boolean;
 export type SnapshotQuery = {
     locale: string;
     /** true: the live row (the editor preview); false: the published snapshot. */
@@ -90,6 +110,8 @@ export type SnapshotQuery = {
     where?: Where;
     order?: EntryOrder;
     limit?: number;
+    /** Rows to skip before `limit` counts, after the order: a paginated list's page (2026-11-13). */
+    offset?: number;
     parent?: string | null;
     /** Only these entries (getEntry by id). */
     ids?: string[];
@@ -120,6 +142,8 @@ export interface EntryStore {
     create(collection: string, fields: Record<string, unknown>, options: CreateEntryOptions, by?: string): Promise<EntryRecord>;
     get(collection: string, id: string): Promise<EntryRecord | null>;
     list(collection: string, options?: ListOptions): Promise<EntryRecord[]>;
+    /** One page of the admin's list with the count of every match: filtered, ordered and cut in the store. */
+    page(collection: string, q: EntryPageQuery): Promise<EntryPage>;
     /** Filters, orders and limits over the version SHOWN: the published snapshot (a row
      *  without one falls back to the live merge), or the live row when `draft` (spec
      *  2026-09-29 content API contract §5). Only rows present in `locale`; the published
@@ -173,15 +197,20 @@ export interface EntryStore {
      * among the destination siblings; omitted, it appends; out-of-range
      * values clamp. Destination siblings are renumbered 1..N afterward.
      * Like `reorder`, `move` does NOT bump `updatedAt`.
+     * `to.locale` is the locale whose list `index` counts in (the default
+     * when omitted); under `locales.order: "perLocale"` only that locale's
+     * order changes, as PageStore.move.
      */
     move(collection: string, id: string, to: {
         parentId: string | null;
         index?: number;
+        locale?: string;
     }, options?: {
         redirect?: boolean;
     }): Promise<EntryRecord>;
-    /** Rewrite manual order to 1..N for the given ids, one batched pass. */
-    reorder(collection: string, orderedIds: string[]): Promise<void>;
+    /** Rewrite manual order to 1..N for the given ids, one batched pass: in `locale` alone under
+     *  `locales.order: "perLocale"` when one is named, else in every locale. */
+    reorder(collection: string, orderedIds: string[], locale?: string): Promise<void>;
     /** The refs index's reverse question: who points at this entry? */
     referencesTo(collection: string, id: string): Promise<EntryUsage[]>;
     /** Reverse lookup by id alone (ids are globally unique) — the fan-out walk. */
@@ -263,4 +292,4 @@ export declare function entryTitleIn(record: EntryRecord, locale: string, schema
  * `COLLATE NOCASE` gives for one type (ASCII only; see MAINTAINERS.md's
  * follow-ups for the mixed-type, JSON-null and non-ASCII edges).
  */
-export declare function compareEntries(order: EntryOrder, seq: (e: EntryRecord) => number): (a: EntryRecord, b: EntryRecord) => number;
+export declare function compareEntries(order: EntryOrder, seq: (e: EntryRecord) => number, locale: string): (a: EntryRecord, b: EntryRecord) => number;

package/dist/entry-store.js

@@ -1,8 +1,8 @@
 // The collection-entry persistence contract — the entries counterpart
 // to PageStore. An entry is ONE node (identity, tree position, the
 // SHARED fields) with one row per locale it exists in (spec 2026-09-06
-// §7): the locale row owns its slug, its publish state and the
-// .localized() fields, and — for a collection registered with
+// §7): the locale row owns its slug, its publish state, its manual
+// position (`sort`, 2026-11-13) and the .localized() fields, and — for a collection registered with
 // every collection — a history of merged snapshots, one row per publish. Nothing falls back
 // to another locale. Writes always flow through this API (never raw
 // table access), which is what lets the refs index stay correct: every
@@ -10,7 +10,7 @@
 // field set. Reorder rewrites sort 1..N in one pass and NEVER touches
 // updatedAt — order is a property of the collection, not an edit.
 import { collectEntryRefs } from "./refs.js";
-import { slugOf, unsupportedLocale } from "./paths.js";
+import { slugOf, sortIn, unsupportedLocale } from "./paths.js";
 /** The field types whose value is an array: a scalar `where` on one is
  *  containment, and any-of on one is refused by the site layer (both
  *  adapters read the text form of the whole array, never its elements). */
@@ -29,6 +29,18 @@ export function matchesWhere(fields, where) {
         return Array.isArray(have) ? have.includes(want) : have === want;
     });
 }
+/** The text a search compares: ASCII letters folded, as SQLite's LIKE folds them (the two stores agree). */
+const foldSearch = (text) => text.replace(/[A-Z]/g, (c) => c.toLowerCase());
+/** Whether an entry's title field holds `search`, in the shared fields or any locale row's (the memory store's
+ *  reading; the SQLite store says the same in SQL). */
+export function matchesSearch(record, titleField, search) {
+    const needle = foldSearch(search);
+    const holds = (fields) => {
+        const v = fields[titleField];
+        return (typeof v === "string" || typeof v === "number") && foldSearch(String(v)).includes(needle);
+    };
+    return holds(record.fields) || Object.values(record.locales).some((row) => holds(row.fields));
+}
 export function schemaOf(collections, name) {
     const schema = collections.find((c) => c.name === name);
     if (!schema)
@@ -138,11 +150,12 @@ export function entryTitleIn(record, locale, schema) {
  * `COLLATE NOCASE` gives for one type (ASCII only; see MAINTAINERS.md's
  * follow-ups for the mixed-type, JSON-null and non-ASCII edges).
  */
-export function compareEntries(order, seq) {
+export function compareEntries(order, seq, locale) {
     return (a, b) => {
         if (order === "manual") {
-            const d = (a.sort ?? Infinity) - (b.sort ?? Infinity);
-            return d !== 0 ? d : seq(a) - seq(b);
+            // The manual order is `locale`'s own (paths.ts sortIn); Infinity on both sides is a tie.
+            const x = sortIn(a, locale), y = sortIn(b, locale);
+            return x !== y ? (x < y ? -1 : 1) : seq(a) - seq(b);
         }
         const dir = order.direction === "asc" ? 1 : -1;
         const value = (e) => order.by === "createdAt" ? e.createdAt : order.by === "updatedAt" ? e.updatedAt : e.fields[order.by];

package/dist/paths.d.ts

@@ -9,10 +9,42 @@ export declare function assertSegment(s: string, what: string): void;
  *  trailing or doubled hyphens. The result passes isSegment
  *  or is "" — a title with no Latin letters or digits makes no slug. */
 export declare function slugify(text: string): string;
+/** `order`: whether pages and manually ordered entries keep ONE order for every locale ("shared", the default) or
+ *  each locale its own ("perLocale") — DESIGN.md, Localization (2026-11-13). */
+export type LocaleOrder = "shared" | "perLocale";
 export type LocaleSet = {
     default: string;
     supported: string[];
+    order?: LocaleOrder;
 };
+/** What order needs of a node: each locale row's own position among the node's siblings. */
+export type Ordered = {
+    locales: Record<string, {
+        sort?: number | null;
+    }>;
+};
+/** A node's position as one locale lists it: that locale's row's; a node absent there stands where its first other
+ *  row (by locale code) puts it, so under a shared order it keeps its place. Infinity = no position, listed last. */
+export declare function sortIn(node: Ordered, locale: string): number;
+/** The nodes in one locale's order. A stable sort: ties keep the input's order, so callers pass creation order. */
+export declare function orderIn<T extends Ordered>(nodes: readonly T[], locale: string): T[];
+/** The position a new last sibling takes in `locale`. */
+export declare function nextSort(siblings: readonly Ordered[], locale: string): number;
+type Placed = {
+    locales: Record<string, {
+        sort: number | null;
+    }>;
+};
+/** A move's order writes. `siblings` are the destination's other children in creation order; `index` is the node's
+ *  final 0-based place in the list as `view` shows it (omitted or out of range, it clamps; omitted appends).
+ *  Shared: every row of every sibling takes the one new numbering. Per locale: only `view`'s rows are renumbered,
+ *  and after a reparent the node goes last in its other locales. Mutates the rows; returns the nodes it changed. */
+export declare function placeNode<T extends Placed>(siblings: readonly T[], node: T, to: {
+    view: string;
+    index?: number;
+    perLocale: boolean;
+    reparented: boolean;
+}): T[];
 /** ONE text for both stores: a locale outside the config set. */
 export declare const unsupportedLocale: (locale: string) => Error;
 export declare function assertSupportedLocale(locale: string, set: LocaleSet): void;
@@ -65,6 +97,7 @@ export type PageLike = {
     /** The locales the node exists in, each with the node's OWN segment there. Presence IS the key (spec 2026-09-06 §3). */
     locales: Record<string, {
         slug: string;
+        sort?: number | null;
     }>;
 };
 export type PagePathOptions = {
@@ -154,3 +187,4 @@ export type PageTreeNode<T extends PageLike> = {
     children: PageTreeNode<T>[];
 };
 export declare function buildPageTree<T extends PageLike>(records: T[], locale: string, opts: PagePathOptions): PageTreeNode<T>[];
+export {};

package/dist/paths.js

@@ -26,6 +26,50 @@ export function slugify(text) {
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-+|-+$/g, "");
 }
+/** A node's position as one locale lists it: that locale's row's; a node absent there stands where its first other
+ *  row (by locale code) puts it, so under a shared order it keeps its place. Infinity = no position, listed last. */
+export function sortIn(node, locale) {
+    const own = node.locales[locale];
+    if (own)
+        return own.sort ?? Infinity;
+    const other = Object.keys(node.locales).sort()[0];
+    return (other === undefined ? null : node.locales[other].sort) ?? Infinity;
+}
+/** The nodes in one locale's order. A stable sort: ties keep the input's order, so callers pass creation order. */
+export function orderIn(nodes, locale) {
+    return [...nodes].sort((a, b) => { const x = sortIn(a, locale), y = sortIn(b, locale); return x === y ? 0 : x < y ? -1 : 1; });
+}
+/** The position a new last sibling takes in `locale`. */
+export function nextSort(siblings, locale) {
+    return siblings.reduce((max, s) => { const n = sortIn(s, locale); return n !== Infinity && n > max ? n : max; }, 0) + 1;
+}
+/** A move's order writes. `siblings` are the destination's other children in creation order; `index` is the node's
+ *  final 0-based place in the list as `view` shows it (omitted or out of range, it clamps; omitted appends).
+ *  Shared: every row of every sibling takes the one new numbering. Per locale: only `view`'s rows are renumbered,
+ *  and after a reparent the node goes last in its other locales. Mutates the rows; returns the nodes it changed. */
+export function placeNode(siblings, node, to) {
+    const changed = new Set();
+    const set = (n, locale, sort) => {
+        const row = n.locales[locale];
+        if (row && row.sort !== sort) {
+            row.sort = sort;
+            changed.add(n);
+        }
+    };
+    const ordered = orderIn(siblings, to.view);
+    ordered.splice(Math.min(Math.max(to.index ?? ordered.length, 0), ordered.length), 0, node);
+    if (!to.perLocale) {
+        ordered.forEach((n, i) => { for (const locale of Object.keys(n.locales))
+            set(n, locale, i + 1); });
+        return [...changed];
+    }
+    ordered.forEach((n, i) => set(n, to.view, i + 1));
+    if (to.reparented)
+        for (const locale of Object.keys(node.locales))
+            if (locale !== to.view)
+                set(node, locale, nextSort(siblings, locale));
+    return [...changed];
+}
 /** ONE text for both stores: a locale outside the config set. */
 export const unsupportedLocale = (locale) => new Error(`smoodly: "${locale}" is not a supported locale.`);
 export function assertSupportedLocale(locale, set) {
@@ -225,8 +269,9 @@ export function entryAlternates(entry, set, advertised, pathIn) {
 }
 export function buildPageTree(records, locale, opts) {
     const byId = (id) => records.find((r) => r.id === id);
-    const build = (parentId) => records
-        .filter((r) => r.parentId === parentId)
+    const build = (parentId) => 
+    // Siblings in the locale's own order (2026-11-13); the input's order settles ties.
+    orderIn(records.filter((r) => r.parentId === parentId), locale)
         .map((r) => ({
         record: r,
         path: pagePathIn(r, byId, locale, opts),

package/dist/reads.d.ts

@@ -47,7 +47,7 @@ export type SmoodlyQueries<C extends readonly CollectionSchema<any, string>[], S
     getPageTree(options?: QueryOptions): Promise<PageTreeItem[]>;
     /** A page by locale-relative path ("/company/about-us") or id. */
     getPage(pathOrId: string, options?: QueryOptions): Promise<PageItem | null>;
-    /** Published entries of a collection: `where` (shared fields), `order`, `limit`, `parent` run in the store. */
+    /** Published entries of a collection: `where` (shared fields), `order`, `limit`, `offset`, `parent` run in the store. */
     getEntries<N extends C[number]["name"]>(collection: N, options?: EntriesQuery): Promise<TypedEntryItem<C, N>[]>;
     getEntry<N extends C[number]["name"]>(collection: N, idOrPath: string, options?: QueryOptions): Promise<TypedEntryItem<C, N> | null>;
     getGlobal<N extends S[number]["name"]>(item: N, options?: QueryOptions): Promise<GlobalValue<S, N> | null>;

package/dist/site.d.ts

@@ -108,13 +108,15 @@ export type PageTreeItem = {
 export type EntryTreeItem = EntryItem & {
     children: EntryTreeItem[];
 };
-/** `where`, `limit`, `parent` and `order` run in the store (spec 2026-09-11 §3); `draft` reads live rows inside the editor preview. */
+/** `where`, `limit`, `offset`, `parent` and `order` run in the store (spec 2026-09-11 §3); `draft` reads live rows inside the editor preview.
+ *  `offset` skips that many entries after the order, before `limit` counts: page N of a list is `{ limit, offset: (N - 1) * limit }`. */
 export type EntryQuery = {
     locale?: string;
     parent?: string | null;
     order?: EntryOrder;
     where?: Where;
     limit?: number;
+    offset?: number;
     draft?: boolean;
     /** Only these entries (`getEntry` by id). */
     ids?: string[];

package/dist/site.js

@@ -48,7 +48,7 @@ export function siteStatics(options) {
             kind: "page",
             locale,
             // No record yet: the id only has to be stable and never a stored one.
-            record: { id: `code:${template}`, parentId: null, template, fixed: spec.key, locales: {}, sort: null },
+            record: { id: `code:${template}`, parentId: null, template, fixed: spec.key, locales: {} },
             template,
             tree: { zones: {} },
             title: spec.title,

package/dist/store.d.ts

@@ -11,6 +11,8 @@ export type PageLocale = {
     /** The node's OWN segment in this locale; the URL is derived (paths.ts). */
     slug: string;
     title: string;
+    /** The node's position among its siblings as this locale lists them; null sorts last. Read with paths.ts orderIn. */
+    sort: number | null;
     status: "draft" | "published";
     draftVersionId: string | null;
     /** The draft version's saved time as the store's own text — the token's second half (spec 2026-09-26 concurrency §1). Null with no pointer. */
@@ -25,7 +27,6 @@ export type PageRecord = {
     parentId: string | null;
     /** null = folder: a node with a title and a position but no page behind it. */
     template: string | null;
-    sort: number | null;
     /** The owner key when code owns the record (spec 2026-09-29 nested paths §3); absent/null = an editor's page. */
     fixed?: string | null;
     /** One entry per locale the page exists in. */
@@ -99,10 +100,15 @@ export interface PageStore {
      * removed from the sibling list first, then spliced back in at `index`.
      * Omitted, it appends; out-of-range values clamp to [0, siblings.length].
      * Refused when the destination lacks one of the page's locales.
+     * `to.locale` is the locale whose list `index` counts in (the default
+     * locale when omitted). Under `locales.order: "perLocale"` only that
+     * locale's order changes, and a reparented page goes last in its other
+     * locales; under "shared" every locale takes the new order.
      */
     move(id: string, to: {
         parentId: string | null;
         index?: number;
+        locale?: string;
     }, options?: {
         redirect?: boolean;
     }): Promise<PageRecord>;

package/dist/store.js

@@ -5,9 +5,10 @@
 // implements the same interface over pages/page_locales/page_versions.
 //
 // The model (spec 2026-09-06): a page is ONE node with ONE row per
-// locale it exists in. The node holds identity and tree position; each
-// locale row owns its slug, title, publish state and version pointers,
-// and each locale has its own history. Nothing falls back to another
+// locale it exists in. The node holds identity and its parent; each
+// locale row owns its slug, title, publish state, version pointers and
+// its position among the siblings (`sort`, 2026-11-13: shared or per
+// locale by `locales.order`), and each locale has its own history. Nothing falls back to another
 // locale — presence IS the row.
 import { ASSET_COLLECTION } from "./media.js";
 import { collectTreeRefs } from "./refs.js";

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const SMOODLY_VERSION = "0.0.58";
+export declare const SMOODLY_VERSION = "0.0.59";

package/dist/version.js

@@ -1,2 +1,2 @@
 // Generated by scripts/write-version.mjs from package.json — do not edit.
-export const SMOODLY_VERSION = "0.0.58";
+export const SMOODLY_VERSION = "0.0.59";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoodly",
-  "version": "0.0.58",
+  "version": "0.0.59",
   "description": "Open-source, code-first CMS for Astro and Next.js: define a component once, it becomes a typed, editable building block.",
   "license": "MIT",
   "engines": {