wiki-formant 0.86.0 → 0.86.2

package/dist/knip.js

@@ -1,31 +1,32 @@
-// knip.ts — the dead-code config every app here shares. An app's own knip.ts
-// spreads it and appends what only it has: `{ ...base, ignoreBinaries:
-// [...base.ignoreBinaries, 'ffmpeg'] }`. Each had kept a copy, and the copies
-// drifted on the one line that matters most: a glob that does not name
-// `.well-known` skips a dotted directory and every agent-surface route in it.
-const entry = [
-    // What the App Router loads by convention and nothing imports.
-    'src/app/**/page.tsx',
-    'src/app/**/layout.tsx',
-    'src/app/**/route.{ts,tsx}',
-    'src/app/**/{error,not-found,loading,global-error}.tsx',
-    'src/app/.well-known/**/route.ts',
-    'src/app/**/{sitemap,robots,manifest,opengraph-image,icon,apple-icon}.{ts,tsx}',
-    'src/proxy.ts',
-    // A module exporting for its test alone reads as dead without the test.
-    'src/**/*.test.ts',
-    // The routines run these from the command line, and they reach into `src`.
-    'scripts/**/*.{ts,mts,mjs}',
-    'studio/**/*.mjs',
-];
-export default {
-    entry,
+// knip.ts — the knip configuration every app here shares: what the App
+// Router loads by convention and nothing imports, the scripts the routines
+// run from the command line, and the two dependencies no TS import names.
+// An app's `knip.ts` spreads it and adds what is its own:
+//
+//   import base from 'wiki-formant/knip';
+//   export default { ...base, ignoreBinaries: [...base.ignoreBinaries, 'ffmpeg'] };
+const config = {
+    $schema: 'https://unpkg.com/knip@6/schema.json',
+    entry: [
+        'src/app/**/page.tsx',
+        'src/app/**/layout.tsx',
+        'src/app/**/route.{ts,tsx}',
+        'src/app/**/{error,not-found,loading,global-error}.tsx',
+        // A dotted directory: a glob that does not name it skips the agent surface.
+        'src/app/.well-known/**/route.ts',
+        'src/app/**/{sitemap,robots,manifest,opengraph-image,icon,apple-icon}.{ts,tsx}',
+        'src/**/*.test.ts',
+        'scripts/**/*.{ts,mts,mjs}',
+        'studio/**/*.mjs',
+    ],
     project: ['src/**/*.{ts,tsx}', 'scripts/**/*.{ts,mts,mjs}', 'studio/**/*.mjs'],
-    ignore: ['src/generated/**'],
-    // The generated Prisma client imports the first; the second is reached through
-    // `@tailwindcss/postcss` and a stylesheet `@import`, neither an import edge.
-    ignoreDependencies: ['@prisma/client', 'tailwindcss'],
-    // The global CLI the scripts' cache invalidation shells out to, kept out of the
-    // dependencies because it put ~330 packages into every build.
+    ignoreDependencies: [
+        // Reached through `@tailwindcss/postcss` and the `@import` in globals.css.
+        'tailwindcss',
+        // Imported by the generated Prisma client.
+        '@prisma/client',
+    ],
+    // The Vercel CLI the scripts shell out to for a cache tag; a global, never a dependency.
     ignoreBinaries: ['vercel'],
 };
+export default config;

package/dist/link-check.d.ts

@@ -76,51 +76,52 @@ export declare function collectBlockLinks<B extends {
 }>(blocks: readonly B[], containers?: (block: B) => B[][] | null): BlockLinks;
 /** `Promise.all` with a ceiling, preserving input order in the results. */
 export declare function mapLimit<T, R>(items: readonly T[], limit: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;
-/** A page as `auditLinks` reads it: where it lives, its blocks, its metadata. */
+/** A page as the audit reads it: its site path and its stored blocks. */
 export interface AuditPage {
     path: string;
     content: unknown;
     metadata?: unknown;
 }
-export interface AuditOptions {
-    /** Every internal path that resolves: pages, category hubs, routes, assets. */
+export interface AuditOptions<B extends {
+    type: string;
+}> {
+    /** Site-relative paths that exist, with trailing slashes dropped. */
     livePaths: ReadonlySet<string>;
-    /** Default `probeExternal`. A wiki with its own special cases wraps it. */
+    /** The probe for one external URL. Default `probeExternal`. */
     probe?: (url: string) => Promise<Probe>;
-    /**
-     * Whether an internal path is the wiki's to check. One it is not (an app
-     * route, say) is kept in `skipped` and never reported broken. Default all.
-     */
+    /** Whether a site-relative link is this checker's to verify. Default every one. */
     internal?: (path: string) => boolean;
-    /** Default 12. */
     concurrency?: number;
+    containers?: (block: B) => B[][] | null;
 }
-export type Referenced<T> = T & {
-    pages: string[];
-};
 export interface LinkAudit {
     externalChecked: number;
-    brokenExternal: Referenced<Probe>[];
-    brokenInternal: Referenced<{
+    brokenExternal: Array<Probe & {
+        pages: string[];
+    }>;
+    brokenInternal: Array<{
         url: string;
-    }>[];
-    /** Internal paths `internal` turned away, each with the pages citing it. */
-    skipped: Map<string, string[]>;
-    /** Every embed, unprobed: a status check on one proves little on its own. */
+        pages: string[];
+    }>;
+    /** Every embed, each with the pages that carry it, for a checker that probes them. */
     embeds: Map<string, {
         kind: string;
         pages: string[];
     }>;
+    /** Internal links `internal` declined, each with its pages. */
+    skipped: Map<string, string[]>;
 }
 /**
- * Every link on every page, probed once per URL: externals by `probe`,
- * internals against `livePaths`. A page's own `/history` and `/edit` resolve
- * with it, and a query is a view of the path it rides on. The two checkers had
- * each written this walk, and each had one of those rules and not the other.
+ * Every link on every page, probed once each, with the pages that carry it.
+ * Metadata strings that name a site count as external links: a wiki's facts
+ * panel cites its sources there, sometimes as a bare domain. Two checkers had each written this walk; what
+ * they still do themselves is decide the live paths, the probe and the report.
  */
-export declare function auditLinks(pages: readonly AuditPage[], opts: AuditOptions): Promise<LinkAudit>;
-/** The human summary of an audit's broken links, under the scope it covered. */
-export declare function printLinkAudit(audit: Pick<LinkAudit, 'externalChecked' | 'brokenExternal' | 'brokenInternal'>, { scope, pagesScanned }: {
-    scope: string;
+export declare function auditLinks<B extends {
+    type: string;
+}>(pages: readonly AuditPage[], opts: AuditOptions<B>): Promise<LinkAudit>;
+/** The human report's first lines: what was checked, and what is broken. */
+export declare function printLinkAudit(audit: LinkAudit, { scope, pagesScanned }: {
+    scope?: string;
     pagesScanned: number;
 }): void;

package/dist/link-check.js

@@ -1,9 +1,9 @@
 // link-check.ts — the dead-link probe wiki sweep scripts share.
 //
-// Node-only (fetch, AbortSignal, URL). No framework, no database: which pages
-// to walk, which paths are live and what else to report stay with the caller,
-// because that is the half that is genuinely per-wiki. The walk over them and
-// the summary of what broke are `auditLinks` and `printLinkAudit`.
+// Node-only (fetch, AbortSignal, URL). No framework, no database: what a
+// checker does with the verdicts — which pages to walk, what counts as an
+// internal path, how to report — stays with the caller, because that is the
+// half that is genuinely per-wiki.
 //
 // EVERY GUARD BELOW WAS PAID FOR BY A FALSE POSITIVE. npmjs.com 403s scripted
 // requests, an expired certificate is not a dead host, a YouTube /embed/ URL
@@ -321,62 +321,68 @@ export async function mapLimit(items, limit, fn) {
     await Promise.all(workers);
     return results;
 }
-// A metadata fact (a website, an X handle's URL) renders as a live link and
-// rots like a citation, but lives outside the blocks; a bare domain counts.
+/** A metadata value that names a site: an absolute URL as it is, a bare `www.` or `host.tld` as https. */
 const metadataUrl = (v) => {
     const s = typeof v === 'string' ? v.trim() : '';
     if (/^https?:\/\//i.test(s))
         return s;
     return /^www\./i.test(s) || /^[a-z0-9.-]+\.[a-z]{2,}(\/|$)/i.test(s) ? `https://${s}` : null;
 };
+const push = (map, key, value) => {
+    const arr = map.get(key);
+    if (arr)
+        arr.push(value);
+    else
+        map.set(key, [value]);
+};
 /**
- * Every link on every page, probed once per URL: externals by `probe`,
- * internals against `livePaths`. A page's own `/history` and `/edit` resolve
- * with it, and a query is a view of the path it rides on. The two checkers had
- * each written this walk, and each had one of those rules and not the other.
+ * Every link on every page, probed once each, with the pages that carry it.
+ * Metadata strings that name a site count as external links: a wiki's facts
+ * panel cites its sources there, sometimes as a bare domain. Two checkers had each written this walk; what
+ * they still do themselves is decide the live paths, the probe and the report.
  */
 export async function auditLinks(pages, opts) {
-    const { livePaths, probe = probeExternal, internal = () => true, concurrency = 12 } = opts;
+    const { livePaths, probe = probeExternal, internal = () => true, concurrency = 12, containers = coreBlockShape().containers } = opts;
     const external = new Map();
-    const internals = new Map();
+    const internalLinks = new Map();
     const skipped = new Map();
     const embeds = new Map();
-    const cite = (map, key, page) => {
-        const refs = map.get(key);
-        if (!refs)
-            map.set(key, [page]);
-        else if (!refs.includes(page))
-            refs.push(page);
-    };
     for (const page of pages) {
-        const links = collectBlockLinks(Array.isArray(page.content) ? page.content : []);
-        const meta = page.metadata && typeof page.metadata === 'object' ? Object.values(page.metadata) : [];
-        for (const url of [...links.external, ...meta.map(metadataUrl).filter((u) => !!u)])
-            cite(external, url, page.path);
-        for (const path of links.internal)
-            cite(internal(path) ? internals : skipped, path, page.path);
-        for (const { kind, url } of links.embeds) {
-            const entry = embeds.get(url) ?? { kind, pages: [] };
+        const blocks = Array.isArray(page.content) ? page.content : [];
+        const links = collectBlockLinks(blocks, containers);
+        for (const v of Object.values((page.metadata ?? {}))) {
+            const url = metadataUrl(v);
+            if (url)
+                links.external.push(url);
+        }
+        for (const u of new Set(links.external))
+            push(external, u, page.path);
+        for (const u of new Set(links.internal))
+            push(internal(u) ? internalLinks : skipped, u, page.path);
+        for (const e of links.embeds) {
+            const entry = embeds.get(e.url) ?? { kind: e.kind, pages: [] };
             if (!entry.pages.includes(page.path))
                 entry.pages.push(page.path);
-            embeds.set(url, entry);
+            embeds.set(e.url, entry);
         }
     }
-    const results = await mapLimit([...external.keys()], concurrency, url => probe(url));
-    const resolves = (url) => {
-        const path = url.split('?')[0];
-        return livePaths.has(path) || livePaths.has(path.replace(/\/(history|edit)$/, ''));
-    };
+    const urls = [...external.keys()];
+    const results = await mapLimit(urls, concurrency, url => probe(url));
     return {
-        externalChecked: external.size,
+        externalChecked: urls.length,
         brokenExternal: results.filter(r => !r.ok).map(r => ({ ...r, pages: external.get(r.url) })),
-        brokenInternal: [...internals].filter(([url]) => !resolves(url)).map(([url, refs]) => ({ url, pages: refs })),
-        skipped,
+        brokenInternal: [...internalLinks.entries()]
+            .filter(([u]) => {
+            const p = u.split('?')[0];
+            return !livePaths.has(p) && !livePaths.has(p.replace(/\/(history|edit)$/, ''));
+        })
+            .map(([url, pages]) => ({ url, pages })),
         embeds,
+        skipped,
     };
 }
-/** The human summary of an audit's broken links, under the scope it covered. */
-export function printLinkAudit(audit, { scope, pagesScanned }) {
+/** The human report's first lines: what was checked, and what is broken. */
+export function printLinkAudit(audit, { scope = '(entire wiki)', pagesScanned }) {
     console.log(`\nLink check — scope: ${scope}`);
     console.log(`Pages scanned: ${pagesScanned} | external links checked: ${audit.externalChecked}`);
     console.log(`\nBroken external (${audit.brokenExternal.length}):`);

package/dist/passkey.d.ts

@@ -14,7 +14,7 @@ export interface PasskeyGate {
     cookie: string;
     /** Whether a session cookie's value is a live session whose passkey is still saved. */
     signedIn(session: string | undefined): Promise<boolean>;
-    /** Whether a request carries a live session: `signedIn` over its cookie, for a write route. */
+    /** `signedIn` for a request's own cookie: the check a write route makes. */
     allows(request: Request): Promise<boolean>;
     /** A single-use invite token, good for `days`. The bin turns it into a link. */
     invite(days?: number): Promise<string>;

package/dist/passkey.js

@@ -54,17 +54,20 @@ export function createPasskeyGate({ sql, rpName, cookie = 'passkey_session', ses
         const value = await issue(sql, 'session', sessionDays * DAY, undefined, passkeyId);
         return setCookie(value, sessionDays * 86_400, secure);
     }
-    const sessionOf = (request) => request.headers.get('cookie')?.split(/;\s*/).find(c => c.startsWith(`${cookie}=`))?.slice(cookie.length + 1);
-    const signedIn = async (value) => !!value &&
-        (await sql(`SELECT 1 FROM "PasskeyToken" t JOIN "Passkey" p ON p.id = t."passkeyId"
-       WHERE t.hash = $1 AND t.kind = 'session' AND t."expiresAt" > now()`, await hash(value))).length > 0;
-    return {
+    const cookieOf = (request) => request.headers
+        .get('cookie')
+        ?.split(/;\s*/)
+        .find(c => c.startsWith(`${cookie}=`))
+        ?.slice(cookie.length + 1);
+    const gate = {
         cookie,
-        signedIn,
-        allows: request => signedIn(sessionOf(request)),
+        allows: request => gate.signedIn(cookieOf(request)),
+        signedIn: async (value) => !!value &&
+            (await sql(`SELECT 1 FROM "PasskeyToken" t JOIN "Passkey" p ON p.id = t."passkeyId"
+         WHERE t.hash = $1 AND t.kind = 'session' AND t."expiresAt" > now()`, await hash(value))).length > 0,
         invite: (days = 1) => issue(sql, 'invite', days * DAY),
         async signOut(request) {
-            const value = sessionOf(request);
+            const value = cookieOf(request);
             if (value)
                 await spend(sql, 'session', value);
             return setCookie('', 0, new URL(request.url).protocol === 'https:');
@@ -131,4 +134,5 @@ export function createPasskeyGate({ sql, rpName, cookie = 'passkey_session', ses
             return session(passkey.id, protocol === 'https:');
         },
     };
+    return gate;
 }

package/dist/scripts.d.ts

@@ -1,33 +1,20 @@
-import type { BannerVariant } from './text.js';
+import { type SaveInput, type WikiPageRow, type WikiStore } from './store.js';
 import { type ChangeType } from './versioning.js';
-import { type PageMetadata, type WikiPageRow } from './store.js';
-/** The slice of a `pg` client every helper here takes. Prisma fits it with `$queryRawUnsafe`. */
-export interface ScriptClient {
-    query(text: string, values?: unknown[]): Promise<{
-        rows: unknown[];
-    }>;
-}
-type Block = {
-    id: string;
-    type: string;
-};
+import type { BannerVariant } from './text.js';
 export declare const uid: () => string;
-export declare const content: (html: string) => {
+export declare const content: (text: string) => {
     id: string;
     type: "content";
     text: string;
 };
-/**
- * A notice. Always pass `text`: the variant's standard message lives in the
- * renderer, not the row, so a banner without it is invisible to search.
- */
+/** Always pass `text`: the renderer's default message lives in React, and search indexes only what the row holds. */
 export declare const banner: (variant: BannerVariant, text: string) => {
     id: string;
     type: "banner";
     variant: BannerVariant;
     text: string;
 };
-/** A facts panel leading an article: `table` is the inner `<table>` HTML. */
+/** A facts panel that leads an article: `table` is the inner `<table>` HTML. */
 export declare const infobox: (table: string) => {
     id: string;
     type: "infobox";
@@ -38,152 +25,72 @@ export declare const infobox: (table: string) => {
     }[];
 };
 /**
- * Throw on a link-grid link or reference list whose URL fields are mis-shaped.
- *
- * The app's validator rejects these, and scripts never reach it. The views drop
- * an entry whose URL fails rather than rendering it inert, so a `{ label, url }`
- * link (the shape is `{ label, href }`) shows as a heading with no pills and
- * nothing reports it. A throw inside `withClient` is a rollback and a failed run.
- */
-export declare function assertLinkShapes(blocks: unknown, where?: string): void;
-/**
- * Mark everything cached under `tag` stale on the project `cwd` is linked to.
- * A script's write reaches no route that would bust it, and pages hold a day.
+ * Refuse block content whose URL-bearing leaves are mis-shaped, before it
+ * reaches the database. `LinkGridView` and `ReferencesView` drop an entry whose
+ * URL fails `safeLinkHref` rather than rendering it inert, so a one-field slip
+ * (`url` for a link, whose shape is `{ label, href }`) shows as a heading with
+ * no pills and nothing reports it. Throws, so `withClient` rolls back.
  */
+export declare function assertLinkShapes(blocks: readonly unknown[], where?: string): void;
+/** `vercel cache invalidate --tag`, reported either way. */
 export declare function invalidate(tag: string, cwd?: string): void;
-/**
- * Run `fn` on a connected client, then release it and its pool. A throw rolls
- * back the open transaction and fails the process: every script writes to the
- * live database, and a half-applied edit must never pass for a success. A run
- * that wrote anything ends by invalidating `tag`.
- */
-export declare function withClient<T>(fn: (client: ScriptClient) => Promise<T>, { tag, cwd }?: {
+/** The slice of a `pg` client a script uses. */
+export interface ScriptClient {
+    query(text: string, values?: unknown[]): Promise<{
+        rows: unknown[];
+    }>;
+}
+export interface WithClientOptions {
+    /** The cache tag a write expires. Default `wiki`. */
     tag?: string;
+    /** Where the Vercel project is linked. Default the working directory. */
     cwd?: string;
-}): Promise<T | undefined>;
-/** The app's own store over a script's client, so a script writes what the editor writes. */
-export declare const storeFor: (client: ScriptClient, siteId?: string) => {
-    siteId: string;
-    hidden: string[];
-    isHidden: (tagPath: string) => boolean;
-    get: (tagPath: string, slug: string) => Promise<NonNullable<WikiPageRow<Block> & {
-        revisionCount: number;
-    }> | null>;
-    getById: (id: string) => Promise<NonNullable<WikiPageRow<Block> & {
-        revisionCount: number;
-    }> | null>;
-    list: (tagPath: string, { sort, limit, offset }?: {
-        sort?: import("./store.js").ListSort;
-        limit?: number;
-        offset?: number;
-    }) => Promise<import("./store.js").WikiPageListing[]>;
-    articles: (tagPath: string, { sort, limit, offset }?: {
-        sort?: import("./store.js").ListSort;
-        limit?: number;
-        offset?: number;
-    }) => Promise<WikiPageRow<Block>[]>;
-    subtree: (tagPath: string) => Promise<import("./store.js").WikiPageRef[]>;
-    recent: ({ tagPath, limit }?: {
-        tagPath?: string;
-        limit?: number;
-    }) => Promise<import("./store.js").WikiPageListing[]>;
-    byIds: (ids: readonly string[]) => Promise<import("./store.js").WikiPageListing[]>;
-    refs: () => Promise<Omit<WikiPageRow<unknown>, "content">[]>;
-    corpus: () => Promise<WikiPageRow<Block>[]>;
-    branch: ({ tagPath, sort, limit, offset, since }?: {
-        tagPath?: string;
-        sort?: import("./store.js").ListSort;
-        limit?: number;
-        offset?: number;
-        since?: Date;
-    }) => Promise<{
-        items: {
-            content: Block[];
-            title: string;
-            id: string;
-            metadata: PageMetadata;
-            tagPath: string;
-            slug: string;
-            siteId: string;
-            version: string;
-            authorId: string | null;
-            lastVerifiedAt: Date | null;
-            createdAt: Date;
-            updatedAt: Date;
-            snippet: string;
-        }[];
-        total: number;
-    }>;
-    counts: () => Promise<{
-        tagPath: string;
-        pages: number;
-    }[]>;
-    stats: () => Promise<{
-        pages: number;
-        updated: Date | null;
-    }>;
-    search: (query: string, { tagPath, skip, take, content: withContent }?: {
-        tagPath?: string | null;
-        skip?: number;
-        take?: number;
-        content?: boolean;
-    }) => Promise<{
-        items: (Omit<WikiPageRow<unknown>, "content"> & {
-            snippet: string;
-        } & {
-            score: number;
-            content?: Block[] | undefined;
-        })[];
-        total: number;
-    }>;
-    history: (pageId: string, { limit, offset }?: {
-        limit?: number;
-        offset?: number;
-    }) => Promise<import("./store.js").WikiRevisionEntry[]>;
-    revision: (pageId: string, revisionId: string) => Promise<import("./store.js").WikiRevisionRow<Block> | null>;
-    save: (input: import("./store.js").SaveInput<Block>) => Promise<import("./store.js").SaveResult<Block>>;
-    restore: (tagPath: string, slug: string, revisionId: string, by?: {
-        authorId?: string | null;
-    }) => Promise<import("./store.js").SaveResult<Block>>;
-    remove: (tagPath: string, slug: string) => Promise<boolean>;
-    verify: (tagPath: string, slug: string) => Promise<boolean>;
+    /** Default `DATABASE_URL`, read from the environment or `./.env`. */
+    url?: string;
+}
+/**
+ * Run `fn` against a connected client, then release the client and the pool.
+ * A throw rolls back whatever transaction was open and fails the process:
+ * every one of these scripts writes to the live database, so a half-applied
+ * edit must never be left behind and never look like a success. A run that
+ * wrote anything ends by expiring the wiki's cache tag, because a script
+ * bypasses the routes that purge the pages they change.
+ */
+export declare function withClient<T>(fn: (client: ScriptClient) => Promise<T>, { tag, cwd, url }?: WithClientOptions): Promise<T | undefined>;
+type AnyBlock = {
+    id: string;
+    type: string;
 };
+/** The app's own store over a script's client, so a script writes exactly what the editor writes. */
+export declare const storeFor: (client: ScriptClient, siteId?: string) => WikiStore<AnyBlock>;
 /** A page row by path, every column: what `writeRevision` takes. Null when there is none. */
-export declare const readPage: (client: ScriptClient, tagPath: string, slug: string, siteId?: string) => Promise<NonNullable<WikiPageRow<Block> & {
-    revisionCount: number;
-}> | null>;
+export declare const readPage: (client: ScriptClient, tagPath: string, slug: string, siteId?: string) => Promise<WikiPageRow<AnyBlock> | null>;
 export interface RevisionOptions {
-    /** The bump, and the revision's change type. Default minor. */
     change?: Exclude<ChangeType, 'none'>;
-    message?: string;
-    /** Stamp `lastVerifiedAt`: the edit re-checked the page's facts. */
+    message?: string | null;
+    /** The writer's word that the page's facts were re-checked. */
     verified?: boolean;
-    /** Write nothing; return the version it would have been. */
+    /** Write nothing; return the version the bump would give. */
     dry?: boolean;
-    metadata?: PageMetadata;
+    metadata?: Record<string, unknown>;
     authorId?: string | null;
+    siteId?: string;
 }
 /**
- * Write edited blocks back to a page row from `readPage` as one revision. The
- * save names the version it read, so an edit landing in between is refused
- * (409) rather than overwritten. Returns the new version.
+ * Write edited blocks back to a page from `readPage` as one revision, through
+ * the store: the page and its revision in one statement, the version bumped
+ * from the stored one by `change`. The save names the version it read, so an
+ * edit landing in between is refused (409) instead of overwritten. Returns the
+ * new version.
  */
-export declare function writeRevision(client: ScriptClient, page: Pick<WikiPageRow, 'tagPath' | 'slug' | 'title' | 'version' | 'siteId'>, blocks: Block[], { change, message, verified, dry, metadata, authorId }?: RevisionOptions): Promise<string>;
+export declare function writeRevision(client: ScriptClient, page: WikiPageRow<AnyBlock>, blocks: AnyBlock[], { change, message, verified, dry, metadata, authorId, siteId }?: RevisionOptions): Promise<string>;
 /**
- * Create a page or update it in place, keyed by site, tag path and slug. A
- * change to its title or blocks writes a revision; a re-run that changes
- * nothing writes none. `change` records that bump instead of the diff's, and
- * always writes one.
+ * Create a page, or replace its title and blocks: a change writes a revision
+ * bumped from the page's own version, a re-run that changes nothing writes
+ * none, and a stated `change` always records one.
  */
-export declare function upsertWikiPage(client: ScriptClient, input: {
-    tagPath: string;
-    slug: string;
-    title: string;
-    content: Block[];
-    metadata?: PageMetadata;
-    message?: string;
-    change?: Exclude<ChangeType, 'none'>;
-    authorId?: string | null;
+export declare function upsertWikiPage(client: ScriptClient, input: SaveInput<AnyBlock> & {
+    content: AnyBlock[];
     siteId?: string;
 }): Promise<'created' | 'updated'>;
 export {};