smoodly 0.0.50 → 0.0.52

package/dist/entry-store.d.ts

@@ -1,9 +1,8 @@
 import type { CollectionSchema, EntryOrder } from "./collections.ts";
 import type { GlobalSchema } from "./global.ts";
 import { type RefEdge, type SectionLike } from "./refs.ts";
-import { MemoryRefIndex } from "./ref-index.ts";
-import { type PathHit, type PathIndex } from "./path-index.ts";
-import { type DraftToken } from "./draft-token.ts";
+import type { PathHit, PathIndex } from "./path-index.ts";
+import type { DraftToken } from "./draft-token.ts";
 import { type LocaleSet } from "./paths.ts";
 export type EntryLocale = {
     /** The entry's segment in this locale; null claims no URL. */
@@ -254,7 +253,7 @@ export declare function entryTitleIn(record: EntryRecord, locale: string, schema
  * Sort comparator for one order rule; `seq` breaks ties by creation. A
  * declared order field is SHARED (collection() refuses a localized one),
  * so `e.fields[order.by]` reads the node. Nulls sort last in BOTH
- * directions (the Supabase adapter uses `nullsFirst: false` to match);
+ * directions (the SQLite list compiler sorts nulls last to match);
  * the creation tiebreak follows `direction` for non-manual orders.
  * Declared fields compare numerically when both values are numbers,
  * otherwise as strings via `localeCompare` — the same order Postgres
@@ -262,88 +261,3 @@ export declare function entryTitleIn(record: EntryRecord, locale: string, schema
  * follow-ups for the mixed-type and JSON-null edges.
  */
 export declare function compareEntries(order: EntryOrder, seq: (e: EntryRecord) => number): (a: EntryRecord, b: EntryRecord) => number;
-/** Comparator for `query`: like compareEntries, but a declared field reads the
- *  merged snapshot, `updatedAt` the locale row's, and an absent, null or empty-string value
- *  sorts last in both directions; ties break by creation order (ascending). */
-export declare function compareSnapshots(order: EntryOrder, locale: string, seq: (id: string) => number): (a: SnapshotRow, b: SnapshotRow) => number;
-export declare class MemoryEntryStore implements EntryStore {
-    private refs;
-    private entries;
-    private versions;
-    /** Insertion order per version — `savedAt` alone can tie within a millisecond. */
-    private versionSeq;
-    private seq;
-    private order;
-    private paths;
-    private locales;
-    private schemas;
-    private elements;
-    constructor(collections: CollectionSchema<any>[], refs?: MemoryRefIndex, options?: EntryStoreOptions);
-    private schema;
-    private row;
-    private must;
-    private byId;
-    private snapshot;
-    private subtree;
-    /** An edit bumps the node and the edited row; `move` and `reorder` never call this. */
-    private bump;
-    /** The draft rule (spec 2026-09-13 history §1) for every collection (spec 2026-09-14 §1):
-     *  the unpublished draft row is rewritten in place and a new one starts only when the
-     *  draft IS the published one. */
-    private recordVersion;
-    /** A published row from before every collection was versioned has no snapshot; give it
-     *  one from what is live BEFORE a write changes the fields, so the site keeps serving it
-     *  and the write lands in a new draft row (spec 2026-09-14 §1). */
-    private ensureLiveSnapshot;
-    private dropVersions;
-    /** Every field set the site can render for this entry: each present
-     *  locale's live view, plus a published snapshot the draft has moved
-     *  past (still rendered by the published site). */
-    private liveFieldSets;
-    private writePaths;
-    private writeRefs;
-    private siblings;
-    /** The friendly pre-check (spec 2026-09-06 §11): a string slug must be
-     *  unique among the siblings PRESENT in that locale; null never
-     *  conflicts. The paths primary key remains the invariant. */
-    private assertSiblingSlug;
-    /** Same collection, within depth. Returns the parent (null at the root). */
-    private assertParent;
-    /** The parent rule: a locale can only be added where the parent has it. */
-    private assertParentHasLocale;
-    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[]>;
-    query(collection: string, q: SnapshotQuery): Promise<SnapshotRow[]>;
-    getMany(collection: string, ids: string[], locale: string, options?: {
-        status?: "published";
-    }): Promise<Record<string, Record<string, unknown>>>;
-    update(collection: string, id: string, locale: string, fields: Record<string, unknown>, by?: string, expected?: DraftToken | null, options?: {
-        redirect?: boolean;
-    }): Promise<EntryRecord>;
-    setStatus(collection: string, id: string, locale: string, status: "draft" | "published", by?: string, expected?: DraftToken | null): Promise<EntryRecord>;
-    discardDraft(collection: string, id: string, locale: string, by?: string, expected?: DraftToken | null): Promise<EntryRecord>;
-    addLocale(collection: string, id: string, locale: string, options: AddEntryLocaleOptions, by?: string): Promise<EntryRecord>;
-    removeLocale(collection: string, id: string, locale: string): Promise<EntryRecord>;
-    scanEntries(): Promise<EntryScan[]>;
-    listVersions(collection: string, id: string, locale: string): Promise<EntryVersion[]>;
-    restore(collection: string, id: string, locale: string, versionId: string, by?: string, expected?: DraftToken | null): Promise<EntryRecord>;
-    getVersion(collection: string, versionId: string): Promise<EntryVersion | null>;
-    move(collection: string, id: string, to: {
-        parentId: string | null;
-        index?: number;
-    }, options?: {
-        redirect?: boolean;
-    }): Promise<EntryRecord>;
-    delete(collection: string, id: string): Promise<void>;
-    reorder(collection: string, orderedIds: string[]): Promise<void>;
-    referencesTo(collection: string, id: string): Promise<EntryUsage[]>;
-    incoming(targetId: string): Promise<{
-        sourceKind: string;
-        sourceId: string;
-    }[]>;
-    resolvePath(locale: string, path: string): Promise<PathHit | null>;
-    pathsIn(collection: string, ids: string[], locale: string): Promise<Record<string, string>>;
-    pathsOf(collection: string, id: string): Promise<{}>;
-    redirectsOf(collection: string, id: string): Promise<Record<string, string[]>>;
-}