smoodly 0.0.57 → 0.0.59

package/dist/admin/shell/entries-list.js

@@ -1,4 +1,5 @@
 import { localeStatusOf } from "./pages-tree.js";
+import { orderIn } from "../../paths.js";
 /** The entry's title in the selected locale, else the default locale's, else any locale's;
  *  "Untitled" when every one is empty (spec 2026-09-14 §4). Display only — a shared
  *  title field reads the same from every locale. */
@@ -23,7 +24,8 @@ export function localizedFieldKeys(meta) {
     return Object.entries(meta.fields).filter(([key, d]) => key === "slug" || d.localized === true).map(([key]) => key);
 }
 export function entryRows(records, meta, registry, locale) {
-    return records.map((record) => {
+    // A manual order is the selected locale's own (2026-11-13); the list arrives in the default locale's.
+    return (meta.manual ? orderIn(records, locale) : records).map((record) => {
         const row = record.locales[locale];
         return {
             id: record.id,
@@ -34,6 +36,33 @@ export function entryRows(records, meta, registry, locale) {
         };
     });
 }
+/** How many entries a list page shows: 20 unless the editor chose more (2026-11-13). */
+export const PAGE_SIZES = [20, 100, 500];
+const PAGE_SIZE_KEY = "smoodly-page-size";
+/** The stored size when it is one of the three, else 20. */
+export function resolvePageSize(stored) {
+    return PAGE_SIZES.find((s) => String(s) === stored) ?? PAGE_SIZES[0];
+}
+export function rememberedPageSize() {
+    let stored = null;
+    try {
+        stored = window.localStorage.getItem(PAGE_SIZE_KEY);
+    }
+    catch { /* storage unavailable: 20 is fine */ }
+    return resolvePageSize(stored);
+}
+export function rememberPageSize(size) {
+    try {
+        window.localStorage.setItem(PAGE_SIZE_KEY, String(size));
+    }
+    catch { /* a convenience only */ }
+}
+/** The pager's "21–40 of 134": null while the list fits the smallest page, where there is nothing to page. */
+export function pageRange(total, offset, shown) {
+    if (total <= PAGE_SIZES[0] || shown === 0)
+        return null;
+    return { from: offset + 1, to: offset + shown };
+}
 /** The list drags only when the order IS the `sort` column and the rows
  *  are siblings: a nested collection's flat index is not a sibling index
  *  (spec 2026-09-09 §5; nested manual collections wait for the entry tree UI). */

package/dist/admin/ui/theme.js

@@ -85,7 +85,8 @@ const TOKENS_DARK = `
   --frame:#0F1120; --sheet:${SHEET_DARK};
   --canvas:#131526; --surface:#242840; --surface-form:#242840; --surface-inset:#1B1E30;
   --menu-bg:#242840;
-  --input-bg:#1B1E30; --input-hover-bg:#1B1E30; --input-focus-bg:#1B1E30;
+  /* A field's edge is drawn in dark: a dialog's fields take the card's own tone there (2026-11-13). */
+  --input-bg:#1B1E30; --input-hover-bg:#1B1E30; --input-focus-bg:#1B1E30; --input-border:var(--line-dashed);
   --line:#33384F; --line-dashed:#444A63; --line-soft:#33384F;
   --text:#EEF0F5; --text-secondary:#C5C8D2; --text-muted:#9A9FB3; --text-subtle:#7C819A; --text-disabled:#4F5570;
   --hover:rgba(238,240,245,.05); --press:rgba(238,240,245,.09); --control-hover:#2C3049; --canvas-ground:var(--control-hover);
@@ -233,7 +234,8 @@ html:has(.sm-admin),body:has(.sm-admin){overscroll-behavior:none}
 .sm-rail__btn[aria-current="page"]:hover,.sm-rail__btn[aria-expanded="true"]:hover{color:var(--rail-active-fg)}
 .sm-rail__btn[aria-current="page"] .sm-rail__tile,.sm-rail__btn[aria-expanded="true"] .sm-rail__tile{background:var(--rail-active-bg)}
 .sm-rail__tile svg{width:18px;height:18px;stroke:currentColor;fill:none;stroke-width:2;stroke-linecap:round;stroke-linejoin:round}
-.sm-rail__label{letter-spacing:.01em;white-space:nowrap}
+/* A collection's own title can be long: it ends in an ellipsis inside the rail (2026-11-13). */
+.sm-rail__label{letter-spacing:.01em;white-space:nowrap;max-width:100%;overflow:hidden;text-overflow:ellipsis}
 /* Not greyed: the reference renders every inactive item at --text and marks
    the unavailable ones only by being inert (no pointer, no hover). */
 .sm-rail__btn[aria-disabled="true"]{cursor:default}
@@ -494,6 +496,17 @@ html:has(.sm-admin),body:has(.sm-admin){overscroll-behavior:none}
 }
 .sm-floatbar .sm-richtext__link{padding:0 4px 4px}
 .sm-floatbar .sm-richtext__menu{position:static;width:300px}
+/* The gap cursor, the caret beside a card with no text line next to it:
+   TipTap's own rule draws it black and reaches the admin document only,
+   so both mounts take it from here, in the text's colour. */
+.sm-richtext__content .ProseMirror-gapcursor,.sm-inline-richtext .ProseMirror-gapcursor{display:none;pointer-events:none;position:absolute;margin:0}
+.sm-richtext__content .ProseMirror-gapcursor:after,.sm-inline-richtext .ProseMirror-gapcursor:after{content:"";display:block;position:absolute;top:-2px;width:20px;border-top:1px solid currentColor;animation:sm-gapcursor-blink 1.1s steps(2,start) infinite}
+.sm-richtext__content.ProseMirror-focused .ProseMirror-gapcursor,.sm-inline-richtext.ProseMirror-focused .ProseMirror-gapcursor{display:block}
+@keyframes sm-gapcursor-blink{to{visibility:hidden}}
+/* Where a dragged card lands, and the grip that says a card's head drags. */
+.sm-dropcursor{background:var(--accent,currentColor);border-radius:1px}
+.sm-rtcard__grip{flex:none;display:grid;place-items:center;width:14px;margin-left:-4px;color:var(--text-subtle,currentColor);opacity:.7}
+.sm-rtcard__head:hover .sm-rtcard__grip{opacity:1}
 /* The canvas editor root: ProseMirror's base rules (TipTap injects its
    stylesheet into the admin document, never the iframe) and nothing of the
    widget's typography — the site's CSS styles the content. */
@@ -551,6 +564,14 @@ html:has(.sm-admin),body:has(.sm-admin){overscroll-behavior:none}
 /* The rows sit in a centred column of at most 1200px inside the card,
    under --table-top of air reserved for the coming search and filters. */
 .sm-table{display:flex;flex-direction:column;padding:var(--table-pad);padding-top:var(--table-top);max-width:1200px;margin:0 auto}
+/* The filter sits in that air, so the column heads stay where they are on a list without one (2026-11-13). */
+.sm-table--tools{padding-top:20px}
+.sm-table__tools{display:flex;align-items:center;gap:12px;height:40px;margin-bottom:20px;padding:0 8px}
+.sm-table__tools .sm-input{max-width:320px}
+/* The pager: the count on the left, the page size and Previous / Next on the right. */
+.sm-table__foot{display:flex;align-items:center;justify-content:space-between;gap:12px;flex-wrap:wrap;padding:16px 8px 8px;color:var(--text-muted);font-size:var(--meta-size)}
+.sm-table__pager{display:flex;align-items:center;gap:12px}
+.sm-seg--size .sm-seg__opt{min-width:44px;font-size:var(--text-sm)}
 .sm-table__head,.sm-row{display:grid;gap:12px;align-items:center;padding:0 8px}
 .sm-table__head{
   height:40px;border-bottom:var(--table-rule);font-family:var(--meta-font);font-weight:500;
@@ -1068,6 +1089,9 @@ html:has(.sm-admin),body:has(.sm-admin){overscroll-behavior:none}
 .sm-mediacard__thumb{display:block;aspect-ratio:4/3;border-radius:var(--radius-sm);overflow:hidden;background:var(--surface-inset)}
 .sm-mediacard__img{width:100%;height:100%;object-fit:cover;display:block}
 .sm-thumb--chip{display:grid;place-items:center;width:100%;height:100%;font-weight:600;color:var(--text-muted);font-size:var(--text-sm)}
+/* A video with no poster: the browser's own opening frame over the chip, which stays where it cannot draw one. */
+.sm-thumb--video{position:relative}
+.sm-thumb--video>video{position:absolute;inset:0;width:100%;height:100%;object-fit:cover;pointer-events:none}
 .sm-mediacard__name{font-weight:500;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 .sm-mediacard__meta{font-size:var(--text-sm);color:var(--text-muted)}
 .sm-media{display:flex;flex-direction:column;gap:6px}

package/dist/assemble.js

@@ -58,4 +58,7 @@ export function checkEntryQuery(schema, collection, o) {
     if (o.limit !== undefined && (!Number.isInteger(o.limit) || o.limit < 0)) {
         throw new Error(`smoodly: getEntries("${collection}"): limit must be a non-negative integer.`);
     }
+    if (o.offset !== undefined && (!Number.isInteger(o.offset) || o.offset < 0)) {
+        throw new Error(`smoodly: getEntries("${collection}"): offset must be a non-negative integer.`);
+    }
 }

package/dist/collections.d.ts

@@ -26,8 +26,11 @@ export type CollectionSchema<F extends BuilderMap = BuilderMap, N extends string
         depth: number;
     };
     order?: EntryOrder;
+    /** `showInNav`: the collection gets its own item in the admin's main navigation, after Pages, in place of its
+     *  line in the Collections menu (2026-11-13). Absent = in the menu. */
     admin?: {
         listColumns?: string[];
+        showInNav?: boolean;
     };
     /** Entries carry SEO & Social values (spec 2026-09-29 content API contract §7): stored under `$seo`, empty values falling back on `titleField` and the named fields. */
     seo?: CollectionSeo;
@@ -48,6 +51,7 @@ export declare function collection<F extends BuilderMap, const N extends string
     order?: EntryOrder;
     admin?: {
         listColumns?: string[];
+        showInNav?: boolean;
     };
     seo?: CollectionSeo;
 }): CollectionSchema<F, N>;

package/dist/collections.js

@@ -11,6 +11,9 @@ export function collection(input) {
     if (Object.prototype.hasOwnProperty.call(input.fields, SEO_KEY)) {
         throw new Error(`smoodly: collection "${input.name}": "${SEO_KEY}" is a reserved key.`);
     }
+    if (input.admin?.showInNav !== undefined && typeof input.admin.showInNav !== "boolean") {
+        throw new Error(`smoodly: collection "${input.name}": admin.showInNav is true or false.`);
+    }
     if (input.tree !== undefined && (!Number.isInteger(input.tree.depth) || input.tree.depth < 1)) {
         throw new Error(`smoodly: collection "${input.name}" declares an invalid tree depth.`);
     }

package/dist/config.d.ts

@@ -1,6 +1,7 @@
 import type { Descriptor } from "./fields.ts";
 import type { CollectionSchema } from "./collections.ts";
 import type { GlobalSchema } from "./global.ts";
+import { type LocaleOrder } from "./paths.ts";
 import { type Addresses } from "./addresses.ts";
 import type { Anchors } from "./anchors.ts";
 import { type ImageQuality } from "./media-cut.ts";
@@ -32,9 +33,12 @@ export type SmoodlyConfig = {
         /** Global content: code-declared singletons (spec 2026-09-07). */
         globals?: GlobalSchema[];
     };
+    /** `order`: whether the page tree and manually ordered collections keep one order for every locale
+     *  ("shared", the default) or each locale its own ("perLocale"): a drag then reorders the locale on screen alone. */
     locales: {
         default: string;
         supported: string[];
+        order?: LocaleOrder;
     };
     /** The site's time zone, an IANA name such as "Europe/Helsinki" (spec
      *  2026-09-25 date pickers §5): editors pick datetimes in it, views

package/dist/config.js

@@ -155,6 +155,10 @@ function assertLocales(config) {
     const twice = supported.find((code, i) => supported.indexOf(code) !== i);
     if (twice !== undefined)
         throw new Error(`smoodly: the locale "${twice}" is listed twice in supported — list each locale once.`);
+    const order = config.locales.order;
+    if (order !== undefined && order !== "shared" && order !== "perLocale") {
+        throw new Error(`smoodly: locales.order is ${JSON.stringify(order)} — use "shared" (one order for every locale) or "perLocale".`);
+    }
 }
 function assertTimeZone(config) {
     if (config.timeZone === undefined)

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.57";
+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.57";
+export const SMOODLY_VERSION = "0.0.59";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoodly",
-  "version": "0.0.57",
+  "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": {