smoodly 0.0.4 → 0.0.6

package/dist/store.d.ts

@@ -2,14 +2,35 @@ import type { PageTree } from "./render.tsx";
 import type { EntryStore } from "./entry-store.ts";
 import { type RefEdge, type SectionLike } from "./refs.ts";
 import type { MemoryRefIndex } from "./ref-index.ts";
+import { type PathIndex } from "./path-index.ts";
+import { type LocaleSet, type PagePathOptions, type PathTarget } from "./paths.ts";
+export type PageI18n = Record<string, {
+    slug?: string;
+    title?: string;
+}>;
 export type PageRecord = {
     id: string;
+    parentId: string | null;
+    /** The node's OWN segment in the default locale; the URL is derived (paths.ts). */
     slug: string;
-    template: string;
+    title: string;
+    i18n: PageI18n | null;
+    /** null = folder: a node with a title and a position but no page behind it. */
+    template: string | null;
     status: "draft" | "published";
-    draftVersionId: string;
+    sort: number | null;
+    locales: string[] | null;
+    draftVersionId: string | null;
     publishedVersionId: string | null;
 };
+export type CreatePageInput = {
+    slug: string;
+    template: string | null;
+    title?: string;
+    parentId?: string | null;
+    i18n?: PageI18n | null;
+    locales?: string[] | null;
+};
 export type PageVersion = {
     id: string;
     pageId: string;
@@ -17,22 +38,33 @@ export type PageVersion = {
     createdAt: number;
 };
 export interface PageStore {
-    createPage(input: {
-        slug: string;
-        template: string;
-    }): Promise<PageRecord>;
-    getPage(slug: string): Promise<PageRecord | null>;
-    /** By-id lookup — the fan-out walk holds page ids, not slugs. */
-    getPageById(id: string): Promise<PageRecord | null>;
-    saveDraft(slug: string, tree: PageTree): Promise<PageVersion>;
-    publish(slug: string): Promise<PageRecord>;
-    getDraftTree(slug: string): Promise<PageTree | null>;
-    getPublishedTree(slug: string): Promise<PageTree | null>;
-    listVersions(slug: string): Promise<PageVersion[]>;
-    /** All pages, slug-ascending — the admin's pages list. */
+    createPage(input: CreatePageInput): Promise<PageRecord>;
+    getPage(id: string): Promise<PageRecord | null>;
     listPages(): Promise<PageRecord[]>;
-    /** Removes the page, its versions and its refs rows. Missing slug: no-op. */
-    deletePage(slug: string): Promise<void>;
+    resolvePath(locale: string, path: string): Promise<PathTarget | null>;
+    pathsOf(id: string): Promise<Record<string, string>>;
+    rename(id: string, patch: {
+        locale: string;
+        slug?: string;
+        title?: string;
+    }): Promise<PageRecord>;
+    /**
+     * Reparents `id` under `to.parentId`. `to.index` is the moved node's
+     * final 0-based position among the destination siblings: the node is
+     * removed from the sibling list first, then spliced back in at `index`.
+     * Omitted, it appends; out-of-range values clamp to [0, siblings.length].
+     */
+    move(id: string, to: {
+        parentId: string | null;
+        index?: number;
+    }): Promise<PageRecord>;
+    setTemplate(id: string, template: string): Promise<PageRecord>;
+    saveDraft(id: string, tree: PageTree): Promise<PageVersion>;
+    publish(id: string): Promise<PageRecord>;
+    getDraftTree(id: string): Promise<PageTree | null>;
+    getPublishedTree(id: string): Promise<PageTree | null>;
+    listVersions(id: string): Promise<PageVersion[]>;
+    deletePage(id: string): Promise<void>;
 }
 /** What a PageStore needs beyond its tables to maintain the refs index
  * and gate publishes. All optional: without `sections` no refs are
@@ -40,7 +72,30 @@ export interface PageStore {
 export type PageStoreOptions = {
     sections?: SectionLike[];
     entries?: EntryStore;
+    /** The shared URL index (one instance for pages AND entries). */
+    paths?: PathIndex;
+    locales?: LocaleSet;
+    homePageSlug?: string;
+    tree?: {
+        depth: number;
+    };
 };
+export declare const DEFAULT_LOCALES: LocaleSet;
+/** The options every adapter resolves the same way. */
+export declare function pathOptions(options: PageStoreOptions): PagePathOptions & {
+    depth: number;
+};
+/** Shared write-side rules, so both adapters throw the same messages. */
+export declare const pageErrors: {
+    notFound: (id: string) => Error;
+    slugTaken: (slug: string) => Error;
+    folder: (id: string) => Error;
+    hasTemplate: (id: string) => Error;
+    homeChildren: () => Error;
+    cycle: () => Error;
+    hasChildren: (id: string) => Error;
+};
+export declare function assertPageI18n(i18n: PageI18n | null | undefined): void;
 /** A page's refs rows cover BOTH live trees — edges(draft) ∪
  * edges(published) — so an entry stays delete-guarded while either tree
  * shows it. Callers dedupe on write (the SQL PK does it for real). */
@@ -48,26 +103,47 @@ export declare function pageRefEdges(draft: PageTree, published: PageTree | null
 /** The publish-integrity gate (DESIGN.md §3): a page must not go live
  * showing entries the published site can't resolve — every referenced
  * entry must exist and be published. Throws naming the offenders. */
-export declare function assertPublishable(slug: string, tree: PageTree, sections: SectionLike[], entries: EntryStore): Promise<void>;
+export declare function assertPublishable(label: string, tree: PageTree, sections: SectionLike[], entries: EntryStore): Promise<void>;
 export declare class MemoryPageStore implements PageStore {
     private options;
     private pages;
     private versions;
+    /** Append-only creation-order tie-break; `size + 1` stays fresh only because entries are never deleted. */
+    private seq;
+    private paths;
+    private opts;
     constructor(options?: PageStoreOptions & {
         refs?: MemoryRefIndex;
     });
+    private byId;
+    private must;
+    private isHome;
+    private hasChildren;
+    private siblings;
+    private assertSlugFree;
+    private subtree;
+    private writePaths;
     private writeRefs;
-    createPage({ slug, template }: {
-        slug: string;
-        template: string;
-    }): Promise<PageRecord>;
-    getPage(slug: string): Promise<PageRecord | null>;
-    getPageById(id: string): Promise<PageRecord | null>;
-    saveDraft(slug: string, tree: PageTree): Promise<PageVersion>;
-    publish(slug: string): Promise<PageRecord>;
-    getDraftTree(slug: string): Promise<PageTree | null>;
-    getPublishedTree(slug: string): Promise<PageTree | null>;
-    listVersions(slug: string): Promise<PageVersion[]>;
+    private newVersion;
+    createPage(input: CreatePageInput): Promise<PageRecord>;
+    getPage(id: string): Promise<PageRecord | null>;
     listPages(): Promise<PageRecord[]>;
-    deletePage(slug: string): Promise<void>;
+    resolvePath(locale: string, path: string): Promise<PathTarget | null>;
+    pathsOf(id: string): Promise<Record<string, string>>;
+    rename(id: string, patch: {
+        locale: string;
+        slug?: string;
+        title?: string;
+    }): Promise<PageRecord>;
+    move(id: string, to: {
+        parentId: string | null;
+        index?: number;
+    }): Promise<PageRecord>;
+    setTemplate(id: string, template: string): Promise<PageRecord>;
+    saveDraft(id: string, tree: PageTree): Promise<PageVersion>;
+    publish(id: string): Promise<PageRecord>;
+    getDraftTree(id: string): Promise<PageTree | null>;
+    getPublishedTree(id: string): Promise<PageTree | null>;
+    listVersions(id: string): Promise<PageVersion[]>;
+    deletePage(id: string): Promise<void>;
 }

package/dist/store.js

@@ -4,6 +4,33 @@
 // implementation and the contract-test subject; the Supabase adapter
 // implements the same interface over pages/page_versions.
 import { collectTreeRefs } from "./refs.js";
+import { MemoryPathIndex } from "./path-index.js";
+import { assertDepth, assertSegment, chainOf, pagePathRows, } from "./paths.js";
+export const DEFAULT_LOCALES = { default: "en", supported: ["en"] };
+/** The options every adapter resolves the same way. */
+export function pathOptions(options) {
+    return {
+        locales: options.locales ?? DEFAULT_LOCALES,
+        homePageSlug: options.homePageSlug ?? "home",
+        depth: options.tree?.depth ?? 1,
+    };
+}
+/** Shared write-side rules, so both adapters throw the same messages. */
+export const pageErrors = {
+    notFound: (id) => new Error(`smoodly: no page "${id}".`),
+    slugTaken: (slug) => new Error(`smoodly: a page with slug "${slug}" already exists under this parent.`),
+    folder: (id) => new Error(`smoodly: "${id}" is a folder — give it a template first.`),
+    hasTemplate: (id) => new Error(`smoodly: "${id}" already has a template.`),
+    homeChildren: () => new Error("smoodly: the home page cannot have child pages."),
+    cycle: () => new Error("smoodly: a page cannot be moved under itself."),
+    hasChildren: (id) => new Error(`smoodly: "${id}" has child pages — move or delete them first.`),
+};
+export function assertPageI18n(i18n) {
+    for (const [locale, v] of Object.entries(i18n ?? {})) {
+        if (v.slug !== undefined)
+            assertSegment(v.slug, `page slug (${locale})`);
+    }
+}
 /** A page's refs rows cover BOTH live trees — edges(draft) ∪
  * edges(published) — so an entry stays delete-guarded while either tree
  * shows it. Callers dedupe on write (the SQL PK does it for real). */
@@ -16,7 +43,7 @@ export function pageRefEdges(draft, published, sections) {
 /** The publish-integrity gate (DESIGN.md §3): a page must not go live
  * showing entries the published site can't resolve — every referenced
  * entry must exist and be published. Throws naming the offenders. */
-export async function assertPublishable(slug, tree, sections, entries) {
+export async function assertPublishable(label, tree, sections, entries) {
     const targets = new Map();
     for (const edge of collectTreeRefs(tree, sections)) {
         if (!targets.has(edge.targetId))
@@ -29,7 +56,7 @@ export async function assertPublishable(slug, tree, sections, entries) {
             offenders.push(`${collection}/${id} (${field}${entry ? "" : ", missing"})`);
     }
     if (offenders.length > 0) {
-        throw new Error(`smoodly: cannot publish "${slug}" — it references entries that are not published: ${offenders.join(", ")}.`);
+        throw new Error(`smoodly: cannot publish "${label}" — it references entries that are not published: ${offenders.join(", ")}.`);
     }
 }
 let counter = 0;
@@ -39,6 +66,50 @@ export class MemoryPageStore {
         this.options = options;
         this.pages = new Map();
         this.versions = new Map();
+        /** Append-only creation-order tie-break; `size + 1` stays fresh only because entries are never deleted. */
+        this.seq = new Map();
+        this.byId = (id) => this.pages.get(id);
+        this.paths = options.paths ?? new MemoryPathIndex();
+        this.opts = pathOptions(options);
+    }
+    must(id) {
+        const page = this.pages.get(id);
+        if (!page)
+            throw pageErrors.notFound(id);
+        return page;
+    }
+    isHome(page) {
+        return page.parentId === null && page.slug === this.opts.homePageSlug;
+    }
+    hasChildren(id) {
+        return [...this.pages.values()].some((p) => p.parentId === id);
+    }
+    siblings(parentId, except) {
+        return [...this.pages.values()]
+            .filter((p) => p.parentId === parentId && p.id !== except)
+            // null sorts last; the SQL equivalent is ORDER BY sort ASC NULLS LAST, created_at ASC.
+            .sort((a, b) => (a.sort ?? Infinity) - (b.sort ?? Infinity) || this.seq.get(a.id) - this.seq.get(b.id));
+    }
+    assertSlugFree(parentId, slug, except) {
+        if (this.siblings(parentId, except).some((p) => p.slug === slug))
+            throw pageErrors.slugTaken(slug);
+    }
+    subtree(id) {
+        const out = [];
+        const walk = (parentId) => {
+            for (const p of this.pages.values())
+                if (p.parentId === parentId) {
+                    out.push(p);
+                    walk(p.id);
+                }
+        };
+        const root = this.must(id);
+        out.push(root);
+        walk(id);
+        return out;
+    }
+    async writePaths(nodes) {
+        await this.paths.rewrite(nodes.map((n) => ({ kind: "page", id: n.id })), pagePathRows(nodes, this.byId, this.opts));
     }
     writeRefs(pageId, draft, published) {
         const { sections, refs } = this.options;
@@ -46,100 +117,205 @@ export class MemoryPageStore {
             return;
         refs.rewrite({ sourceKind: "page", sourceId: pageId }, pageRefEdges(draft, published, sections));
     }
-    async createPage({ slug, template }) {
-        if (this.pages.has(slug))
-            throw new Error(`smoodly: a page with slug "${slug}" already exists.`);
-        const pageId = uid();
-        const version = { id: uid(), pageId, tree: { zones: {} }, createdAt: Date.now() };
+    newVersion(pageId, tree) {
+        const version = { id: uid(), pageId, tree: structuredClone(tree), createdAt: Date.now() };
         this.versions.set(version.id, version);
+        return version;
+    }
+    async createPage(input) {
+        assertSegment(input.slug, "page slug");
+        assertPageI18n(input.i18n);
+        const parentId = input.parentId ?? null;
+        if (parentId !== null) {
+            const parent = this.must(parentId);
+            if (this.isHome(parent))
+                throw pageErrors.homeChildren();
+            assertDepth(chainOf(parent, this.byId).length + 1, this.opts.depth, "the page");
+        }
+        this.assertSlugFree(parentId, input.slug);
+        const id = uid();
+        const version = input.template === null ? null : this.newVersion(id, { zones: {} });
         const page = {
-            id: pageId,
-            slug,
-            template,
+            id,
+            parentId,
+            slug: input.slug,
+            title: input.title ?? input.slug,
+            i18n: input.i18n ?? null,
+            template: input.template,
             status: "draft",
-            draftVersionId: version.id,
+            // An ordering hint, not a unique key: duplicates are possible after
+            // moves/deletes, and the creation-order tie-break settles them.
+            sort: this.siblings(parentId).length + 1,
+            locales: input.locales ?? null,
+            draftVersionId: version?.id ?? null,
             publishedVersionId: null,
         };
-        this.pages.set(slug, page);
+        this.pages.set(id, page);
+        this.seq.set(id, this.seq.size + 1);
+        try {
+            await this.writePaths([page]);
+        }
+        catch (e) {
+            this.pages.delete(id);
+            if (version)
+                this.versions.delete(version.id);
+            throw e;
+        }
         return { ...page };
     }
-    async getPage(slug) {
-        const page = this.pages.get(slug);
+    async getPage(id) {
+        const page = this.pages.get(id);
         return page ? { ...page } : null;
     }
-    async getPageById(id) {
-        for (const page of this.pages.values())
-            if (page.id === id)
-                return { ...page };
-        return null;
+    async listPages() {
+        return [...this.pages.values()]
+            // null sorts last; the SQL equivalent is ORDER BY sort ASC NULLS LAST, created_at ASC.
+            .sort((a, b) => (a.sort ?? Infinity) - (b.sort ?? Infinity) || this.seq.get(a.id) - this.seq.get(b.id))
+            .map((p) => ({ ...p }));
+    }
+    resolvePath(locale, path) {
+        return this.paths.resolve(locale, path);
     }
-    async saveDraft(slug, tree) {
-        const page = this.pages.get(slug);
-        if (!page)
-            throw new Error(`smoodly: no page with slug "${slug}".`);
-        const version = {
-            id: uid(),
-            pageId: page.id,
-            tree: structuredClone(tree),
-            createdAt: Date.now(),
-        };
-        this.versions.set(version.id, version);
+    pathsOf(id) {
+        return this.paths.pathsOf({ kind: "page", id });
+    }
+    async rename(id, patch) {
+        const page = this.must(id);
+        if (patch.slug !== undefined)
+            assertSegment(patch.slug, `page slug (${patch.locale})`);
+        // A rename that turns this node INTO the home node (root, default-locale
+        // slug === homePageSlug) is subject to the same invariant as createPage:
+        // the home page cannot have child pages.
+        if (patch.locale === this.opts.locales.default &&
+            patch.slug !== undefined &&
+            page.parentId === null &&
+            patch.slug === this.opts.homePageSlug &&
+            this.hasChildren(id)) {
+            throw pageErrors.homeChildren();
+        }
+        const before = { ...page, i18n: page.i18n ? structuredClone(page.i18n) : null };
+        if (patch.locale === this.opts.locales.default) {
+            if (patch.slug !== undefined) {
+                this.assertSlugFree(page.parentId, patch.slug, id);
+                page.slug = patch.slug;
+            }
+            if (patch.title !== undefined)
+                page.title = patch.title;
+        }
+        else {
+            const i18n = { ...(page.i18n ?? {}) };
+            i18n[patch.locale] = { ...(i18n[patch.locale] ?? {}), ...(patch.slug !== undefined ? { slug: patch.slug } : {}), ...(patch.title !== undefined ? { title: patch.title } : {}) };
+            page.i18n = i18n;
+        }
+        try {
+            await this.writePaths(this.subtree(id));
+        }
+        catch (e) {
+            Object.assign(page, before);
+            throw e;
+        }
+        return { ...page };
+    }
+    async move(id, to) {
+        const page = this.must(id);
+        if (to.parentId !== null) {
+            const parent = this.must(to.parentId);
+            if (to.parentId === id || chainOf(parent, this.byId).some((n) => n.id === id))
+                throw pageErrors.cycle();
+            if (this.isHome(parent))
+                throw pageErrors.homeChildren();
+            const subtreeDepth = Math.max(...this.subtree(id).map((n) => chainOf(n, this.byId).length)) - chainOf(page, this.byId).length + 1;
+            assertDepth(chainOf(parent, this.byId).length + subtreeDepth, this.opts.depth, "the page");
+        }
+        else if (page.slug === this.opts.homePageSlug && this.hasChildren(id)) {
+            // Moving a home-slugged node TO the root is the mirror case of the
+            // rename guard above: it would make it the home node while it still
+            // has children.
+            throw pageErrors.homeChildren();
+        }
+        if (to.parentId !== page.parentId)
+            this.assertSlugFree(to.parentId, page.slug, id);
+        const before = { ...page };
+        page.parentId = to.parentId;
+        const siblings = this.siblings(to.parentId, id);
+        const index = Math.min(Math.max(to.index ?? siblings.length, 0), siblings.length);
+        siblings.splice(index, 0, page);
+        const previousSort = new Map(siblings.map((s) => [s.id, s.sort]));
+        siblings.forEach((s, i) => (s.sort = i + 1));
+        try {
+            await this.writePaths(this.subtree(id));
+        }
+        catch (e) {
+            Object.assign(page, before);
+            for (const s of siblings)
+                s.sort = previousSort.get(s.id) ?? null;
+            throw e;
+        }
+        return { ...page };
+    }
+    async setTemplate(id, template) {
+        const page = this.must(id);
+        if (page.template !== null)
+            throw pageErrors.hasTemplate(id);
+        page.template = template;
+        page.draftVersionId = this.newVersion(id, { zones: {} }).id;
+        return { ...page };
+    }
+    async saveDraft(id, tree) {
+        const page = this.must(id);
+        if (page.template === null)
+            throw pageErrors.folder(id);
+        const version = this.newVersion(id, tree);
         page.draftVersionId = version.id;
-        const published = page.publishedVersionId
-            ? (this.versions.get(page.publishedVersionId)?.tree ?? null)
-            : null;
-        this.writeRefs(page.id, version.tree, published);
+        const published = page.publishedVersionId ? (this.versions.get(page.publishedVersionId)?.tree ?? null) : null;
+        this.writeRefs(id, version.tree, published);
         return { ...version };
     }
-    async publish(slug) {
-        const page = this.pages.get(slug);
-        if (!page)
-            throw new Error(`smoodly: no page with slug "${slug}".`);
+    async publish(id) {
+        const page = this.must(id);
+        if (page.template === null || !page.draftVersionId)
+            throw pageErrors.folder(id);
         const { sections, entries } = this.options;
-        if (sections && entries) {
-            const draft = this.versions.get(page.draftVersionId)?.tree ?? { zones: {} };
-            await assertPublishable(slug, draft, sections, entries);
-        }
+        const draft = this.versions.get(page.draftVersionId)?.tree ?? { zones: {} };
+        if (sections && entries)
+            await assertPublishable(page.slug, draft, sections, entries);
         page.publishedVersionId = page.draftVersionId;
         page.status = "published";
-        const tree = this.versions.get(page.draftVersionId)?.tree ?? { zones: {} };
-        this.writeRefs(page.id, tree, null); // draft IS published now — one tree
+        this.writeRefs(id, draft, null);
         return { ...page };
     }
-    async getDraftTree(slug) {
-        const page = this.pages.get(slug);
-        if (!page)
+    async getDraftTree(id) {
+        const page = this.pages.get(id);
+        if (!page?.draftVersionId)
             return null;
         return structuredClone(this.versions.get(page.draftVersionId)?.tree ?? null);
     }
-    async getPublishedTree(slug) {
-        const page = this.pages.get(slug);
+    async getPublishedTree(id) {
+        const page = this.pages.get(id);
         if (!page?.publishedVersionId)
             return null;
         return structuredClone(this.versions.get(page.publishedVersionId)?.tree ?? null);
     }
-    async listVersions(slug) {
-        const page = this.pages.get(slug);
-        if (!page)
-            return [];
+    async listVersions(id) {
         return [...this.versions.values()]
-            .filter((v) => v.pageId === page.id)
+            .filter((v) => v.pageId === id)
             .sort((a, b) => b.createdAt - a.createdAt || b.id.localeCompare(a.id))
             .map((v) => ({ ...v, tree: structuredClone(v.tree) }));
     }
-    async listPages() {
-        return [...this.pages.values()]
-            .sort((a, b) => a.slug.localeCompare(b.slug))
-            .map((p) => ({ ...p }));
-    }
-    async deletePage(slug) {
-        const page = this.pages.get(slug);
+    async deletePage(id) {
+        const page = this.pages.get(id);
         if (!page)
             return;
-        for (const [id, v] of this.versions)
-            if (v.pageId === page.id)
-                this.versions.delete(id);
-        this.options.refs?.remove({ sourceKind: "page", sourceId: page.id });
-        this.pages.delete(slug);
+        if (this.hasChildren(id))
+            throw pageErrors.hasChildren(id);
+        // The index removal goes first: in the Supabase adapter it is a network
+        // call that can fail, and a failed rewrite must leave this store's own
+        // state (versions, refs, the page map) untouched.
+        await this.paths.remove([{ kind: "page", id }]);
+        for (const [vid, v] of this.versions)
+            if (v.pageId === id)
+                this.versions.delete(vid);
+        this.options.refs?.remove({ sourceKind: "page", sourceId: id });
+        this.pages.delete(id);
     }
 }

package/dist/supabase-entry-store.d.ts

@@ -1,13 +1,21 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
 import type { CollectionSchema } from "./collections.ts";
-import type { EntryRecord, EntryStore, EntryUsage, ListOptions } from "./entry-store.ts";
+import type { CreateEntryOptions, EntryRecord, EntryStore, EntryStoreOptions, EntryUsage, ListOptions } from "./entry-store.ts";
 export declare class SupabaseEntryStore implements EntryStore {
     private db;
     private collections;
-    constructor(db: SupabaseClient, collections: CollectionSchema<any>[]);
+    private paths;
+    private locales;
+    constructor(db: SupabaseClient, collections: CollectionSchema<any>[], options?: EntryStoreOptions);
     private fail;
+    private failWriteError;
     private writeRefs;
-    create(collection: string, fields: Record<string, unknown>): Promise<EntryRecord>;
+    private byIdMap;
+    private chain;
+    private subtree;
+    private writePaths;
+    private assertParent;
+    create(collection: string, fields: Record<string, unknown>, options?: CreateEntryOptions): Promise<EntryRecord>;
     get(collection: string, id: string): Promise<EntryRecord | null>;
     list(collection: string, options?: ListOptions): Promise<EntryRecord[]>;
     getMany(collection: string, ids: string[], options?: {
@@ -16,7 +24,13 @@ export declare class SupabaseEntryStore implements EntryStore {
     private patch;
     update(collection: string, id: string, fields: Record<string, unknown>): Promise<EntryRecord>;
     setStatus(collection: string, id: string, status: "draft" | "published"): Promise<EntryRecord>;
+    move(collection: string, id: string, to: {
+        parentId: string | null;
+        index?: number;
+    }): Promise<EntryRecord>;
     delete(collection: string, id: string): Promise<void>;
+    resolvePath(locale: string, path: string): Promise<import("./paths.ts").PathTarget | null>;
+    pathsOf(collection: string, id: string): Promise<Record<string, string>>;
     reorder(collection: string, orderedIds: string[]): Promise<void>;
     incoming(targetId: string): Promise<{
         sourceKind: string;