emdash-vibe-editor 0.1.0 → 0.2.0

package/dist/lib/blockTypes.d.ts

@@ -0,0 +1,22 @@
+import type { VibeEditorOptions } from '../types.js';
+import { type BlockSchema, type BlockTypes } from './blocks.js';
+export type BlockTypeSource = () => Promise<BlockTypes | null>;
+/** Where block types come from; tests give their own (there is no site database there). */
+export declare function setBlockTypeSource(next: BlockTypeSource | null): void;
+/**
+ * Where the fields of the site's sections are defined: EmDash's block types
+ * (narrowed to `opts.blocks` when given), else `opts.blocks` alone; null when
+ * neither is there.
+ */
+export declare function loadBlockSchema(opts: VibeEditorOptions): Promise<BlockSchema | null>;
+/** A blocks field as ctx.schema gives it. */
+export interface BlocksField {
+    slug: string;
+    type: string;
+    validation?: unknown;
+}
+/**
+ * Why EmDash would refuse `next` as the field's new value (given what it is
+ * now), or null when it takes it.
+ */
+export declare function blocksProblem(field: BlocksField, next: unknown[], previous: unknown, types: BlockTypes): Promise<string | null>;

package/dist/lib/blockTypes.js

@@ -0,0 +1,113 @@
+/**
+ * What the fields inside page-builder sections are, and EmDash's own check
+ * of a blocks value.
+ *
+ * The schema EmDash gives plugins (ctx.schema) shows a blocks field without
+ * its block types. This plugin runs in the site's own process (a native
+ * plugin), so it reads them the way EmDash's content API does: its public
+ * resolveBlockTypes() on the site's database (getDb() from emdash/runtime).
+ * That works where the site's build bundles the plugin (Cloudflare Workers,
+ * or Node with the plugin in Vite's ssr.noExternal); where Node loads the
+ * plugin on its own, EmDash's database isn't reachable from it, and the site
+ * declares the editable fields in the plugin's `blocks` option instead.
+ *
+ * With EmDash's block types, a changed blocks value is checked with EmDash's
+ * own normalizeBlocksData() before it is written, so the plugin never stores
+ * something EmDash's admin would refuse to save (a link that isn't one, a
+ * picture without an id, a text over its length).
+ */
+import { normalizeBlocksData, resolveBlockTypes } from 'emdash';
+import { kindOf } from './blocks.js';
+async function fromEmDash() {
+    try {
+        const { getDb } = await import('emdash/runtime');
+        return (await resolveBlockTypes(await getDb()));
+    }
+    catch {
+        return null;
+    }
+}
+let source = fromEmDash;
+/** Where block types come from; tests give their own (there is no site database there). */
+export function setBlockTypeSource(next) {
+    source = next || fromEmDash;
+}
+/** A declared field as EmDash would define it. */
+function declared(slug, d) {
+    if (d === 'text')
+        return { slug, type: 'string' };
+    if (d === 'portableText' || d === 'image')
+        return { slug, type: d };
+    if (!d || typeof d !== 'object')
+        return null;
+    if (d.type === 'text') {
+        const t = d;
+        return { slug, type: 'string', required: t.required === true, validation: typeof t.maxLength === 'number' ? { maxLength: t.maxLength } : null };
+    }
+    const subFields = Object.entries(d)
+        .map(([sub, v]) => (v === 'portableText' || (v && typeof v === 'object' && v.type !== 'text') ? null : declared(sub, v)))
+        .filter((f) => !!f);
+    return { slug, type: 'repeater', validation: { subFields } };
+}
+function declaredFields(decl) {
+    return Object.entries(decl)
+        .map(([slug, d]) => declared(slug, d))
+        .filter((f) => !!f);
+}
+/** EmDash's fields, only those declared, each only when EmDash's type is what was declared. */
+function narrow(real, decl) {
+    const out = [];
+    for (const d of decl) {
+        const r = real.find((f) => f.slug === d.slug);
+        if (!r)
+            continue;
+        if (d.type === 'repeater') {
+            if (r.type !== 'repeater')
+                continue;
+            out.push({ ...r, validation: { ...(r.validation || {}), subFields: narrow(r.validation?.subFields || [], d.validation?.subFields || []) } });
+        }
+        else if (kindOf(r.type) && kindOf(r.type) === kindOf(d.type)) {
+            out.push(r);
+        }
+    }
+    return out;
+}
+/**
+ * Where the fields of the site's sections are defined: EmDash's block types
+ * (narrowed to `opts.blocks` when given), else `opts.blocks` alone; null when
+ * neither is there.
+ */
+export async function loadBlockSchema(opts) {
+    const decl = opts.blocks && typeof opts.blocks === 'object' ? opts.blocks : null;
+    const own = (type) => (decl && Object.prototype.hasOwnProperty.call(decl, type) ? declaredFields(decl[type]) : null);
+    const types = await source();
+    if (types) {
+        return {
+            types,
+            fieldsOf(type, version) {
+                const fields = types.get(type)?.versions.find((v) => v.version === version)?.fields || null;
+                if (!fields || !decl)
+                    return fields;
+                const mine = own(type);
+                return mine ? narrow(fields, mine) : null;
+            },
+        };
+    }
+    if (!decl)
+        return null;
+    return { types: null, fieldsOf: (type) => own(type) };
+}
+/**
+ * Why EmDash would refuse `next` as the field's new value (given what it is
+ * now), or null when it takes it.
+ */
+export async function blocksProblem(field, next, previous, types) {
+    try {
+        const collection = { fields: [field] };
+        await normalizeBlocksData(null, collection, { [field.slug]: next }, { [field.slug]: previous }, {}, true, types);
+        return null;
+    }
+    catch (err) {
+        return err instanceof Error ? err.message : String(err);
+    }
+}

package/dist/lib/blocks.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Fields inside an EmDash `blocks` field (page-builder sections).
+ *
+ * The site marks them with a dotted path in the field of its edit mark:
+ *
+ *   <blocksField>.<blockKey>.<fieldSlug>                        a block's own field
+ *   <blocksField>.<blockKey>.<repeaterSlug>.<index>.<subSlug>   a repeater row's field (index from 0)
+ *
+ * A block is stored as { _type, _version, ...fields, _key } and a repeater as
+ * an array of plain objects. What a field is comes from the block type's
+ * definition in EmDash (the version the block was written with): only text
+ * (`string`, `text`), rich text (`portableText`) and pictures (`image`) can
+ * be edited here; links, choices, dates, files, numbers and the rest can't.
+ */
+export interface BlockPath {
+    /** The entry's blocks field. */
+    top: string;
+    /** The block's `_key`. */
+    key: string;
+    /** The field of the block (for a repeater row: the repeater). */
+    slug: string;
+    /** A repeater row's index and its field. */
+    index?: number;
+    sub?: string;
+}
+/** A field of a block type, or of a repeater's rows, as EmDash defines it. */
+export interface FieldDef {
+    slug: string;
+    type: string;
+    required?: boolean;
+    validation?: {
+        maxLength?: number;
+        minLength?: number;
+        subFields?: FieldDef[];
+    } | null;
+}
+/** A block type as EmDash's block type registry gives it. */
+export interface BlockTypeDef {
+    slug: string;
+    currentVersion: number;
+    versions: {
+        version: number;
+        fields: FieldDef[];
+    }[];
+}
+export type BlockTypes = Map<string, BlockTypeDef>;
+/**
+ * Where a block's fields are defined: EmDash's block types when they can be
+ * read here (`types`), else what the site declared in the plugin's options.
+ */
+export interface BlockSchema {
+    /** The fields of a block of this type, saved with this version; null when unknown. */
+    fieldsOf(type: string, version: unknown): FieldDef[] | null;
+    /** EmDash's block types, to check a new value with; null when only declared. */
+    types: BlockTypes | null;
+}
+export type Kind = 'text' | 'portableText' | 'image';
+/** What the overlay edits for an EmDash field type; null for every other type. */
+export declare function kindOf(type: string): Kind | null;
+/** What the save must keep to: a text's length, and whether it may be empty. */
+export interface Rules {
+    required: boolean;
+    maxLength?: number;
+    minLength?: number;
+}
+export type Parsed = {
+    path: BlockPath;
+} | {
+    error: string;
+};
+/** Whether a field names something inside a blocks field (it has a dot). */
+export declare function isPath(field: string): boolean;
+/** The path a dotted field names, or why it can't be one. */
+export declare function parsePath(field: string): Parsed;
+type Obj = Record<string, unknown>;
+/** The block with this `_key` in a blocks value, or null. */
+export declare function findBlock(blocks: unknown, key: string): Obj | null;
+export type Resolved = {
+    kind: Kind;
+    rules: Rules;
+    value: unknown;
+    label: string;
+} | {
+    missing: true;
+} | {
+    refused: string;
+};
+/**
+ * The field a path names in an entry's blocks value, by the block type's
+ * definition: what it is, what a save must keep to, its value now, and a
+ * name for it the AI understands (the block's type and the field's slug).
+ */
+export declare function resolve(blocks: unknown, path: BlockPath, schema: BlockSchema): Resolved;
+/** Why a new text can't be saved in a field with these rules, or null. */
+export declare function textProblem(rules: Rules, value: string): string | null;
+/**
+ * A copy of the blocks value with the one value at `path` replaced; every
+ * other block, key and version as it was. Null when the block or row isn't
+ * there.
+ */
+export declare function setAt(blocks: unknown, path: BlockPath, value: unknown): unknown[] | null;
+export {};

package/dist/lib/blocks.js

@@ -0,0 +1,151 @@
+/**
+ * Fields inside an EmDash `blocks` field (page-builder sections).
+ *
+ * The site marks them with a dotted path in the field of its edit mark:
+ *
+ *   <blocksField>.<blockKey>.<fieldSlug>                        a block's own field
+ *   <blocksField>.<blockKey>.<repeaterSlug>.<index>.<subSlug>   a repeater row's field (index from 0)
+ *
+ * A block is stored as { _type, _version, ...fields, _key } and a repeater as
+ * an array of plain objects. What a field is comes from the block type's
+ * definition in EmDash (the version the block was written with): only text
+ * (`string`, `text`), rich text (`portableText`) and pictures (`image`) can
+ * be edited here; links, choices, dates, files, numbers and the rest can't.
+ */
+/** What can be edited here, by EmDash field type. */
+const KINDS = { string: 'text', text: 'text', portableText: 'portableText', image: 'image' };
+/** What the overlay edits for an EmDash field type; null for every other type. */
+export function kindOf(type) {
+    return Object.prototype.hasOwnProperty.call(KINDS, type) ? KINDS[type] : null;
+}
+function fits(kind, value) {
+    if (kind === 'text')
+        return typeof value === 'string';
+    if (kind === 'portableText')
+        return Array.isArray(value) && value.every((b) => isObject(b) && typeof b._type === 'string');
+    return isObject(value);
+}
+// Field slugs and block keys: letters, digits, _ and -; nothing that walks elsewhere.
+const SEGMENT = /^[A-Za-z0-9_-]{1,100}$/;
+const INDEX = /^(0|[1-9][0-9]{0,5})$/;
+const CANT = 'Dette feltet kan ikke endres her.';
+/** Whether a field names something inside a blocks field (it has a dot). */
+export function isPath(field) {
+    return field.includes('.');
+}
+/** The path a dotted field names, or why it can't be one. */
+export function parsePath(field) {
+    const parts = field.split('.');
+    if (parts.length !== 3 && parts.length !== 5)
+        return { error: 'Ugyldig felt.' };
+    const [top, key, slug, index, sub] = parts;
+    if (![top, key, slug].every((s) => SEGMENT.test(s)))
+        return { error: 'Ugyldig felt.' };
+    if (parts.length === 3)
+        return { path: { top, key, slug } };
+    if (!INDEX.test(index) || !SEGMENT.test(sub))
+        return { error: 'Ugyldig felt.' };
+    return { path: { top, key, slug, index: Number(index), sub } };
+}
+function isObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+/** The block with this `_key` in a blocks value, or null. */
+export function findBlock(blocks, key) {
+    if (!Array.isArray(blocks))
+        return null;
+    const b = blocks.find((x) => isObject(x) && x._key === key);
+    return b || null;
+}
+// `_type`, `_version`, `_key` and the like are EmDash's, never content.
+function defOf(fields, slug) {
+    if (slug.startsWith('_') || !Array.isArray(fields))
+        return null;
+    return fields.find((f) => f && f.slug === slug) || null;
+}
+/**
+ * The field a path names in an entry's blocks value, by the block type's
+ * definition: what it is, what a save must keep to, its value now, and a
+ * name for it the AI understands (the block's type and the field's slug).
+ */
+export function resolve(blocks, path, schema) {
+    const block = findBlock(blocks, path.key);
+    if (!block)
+        return { missing: true };
+    const type = typeof block._type === 'string' && SEGMENT.test(block._type) ? block._type : null;
+    const fields = type ? schema.fieldsOf(type, block._version) : null;
+    if (!type || !fields)
+        return { refused: CANT };
+    const field = defOf(fields, path.slug);
+    if (!field)
+        return { refused: CANT };
+    let def = field;
+    let value = block[path.slug];
+    let label = `${type}.${field.slug}`;
+    if (path.sub !== undefined) {
+        // Only a repeater has rows; rich text is an array too, but of blocks.
+        if (field.type !== 'repeater')
+            return { refused: CANT };
+        const sub = defOf(field.validation?.subFields, path.sub);
+        if (!sub)
+            return { refused: CANT };
+        const rows = block[path.slug];
+        const row = Array.isArray(rows) && path.index < rows.length ? rows[path.index] : undefined;
+        if (!isObject(row))
+            return { refused: 'Fant ikke raden i seksjonen. Last siden på nytt.' };
+        def = sub;
+        value = row[path.sub];
+        label = `${label}.${sub.slug}`;
+    }
+    const kind = kindOf(def.type);
+    if (!kind)
+        return { refused: CANT };
+    // What is there must be what the field holds (EmDash checks its own writes; a declared field is trusted less).
+    if (value !== null && value !== undefined && !fits(kind, value))
+        return { refused: CANT };
+    const v = def.validation || {};
+    return {
+        kind,
+        rules: {
+            required: !!def.required,
+            ...(typeof v.maxLength === 'number' ? { maxLength: v.maxLength } : {}),
+            ...(typeof v.minLength === 'number' ? { minLength: v.minLength } : {}),
+        },
+        value,
+        label,
+    };
+}
+/** Why a new text can't be saved in a field with these rules, or null. */
+export function textProblem(rules, value) {
+    if (!value.trim())
+        return 'Feltet kan ikke være tomt.';
+    const length = value.length;
+    if (rules.maxLength !== undefined && length > rules.maxLength)
+        return `Teksten er for lang: høyst ${rules.maxLength} tegn (nå ${length}).`;
+    if (rules.minLength !== undefined && length < rules.minLength)
+        return `Teksten er for kort: minst ${rules.minLength} tegn.`;
+    return null;
+}
+/**
+ * A copy of the blocks value with the one value at `path` replaced; every
+ * other block, key and version as it was. Null when the block or row isn't
+ * there.
+ */
+export function setAt(blocks, path, value) {
+    if (!Array.isArray(blocks))
+        return null;
+    const out = structuredClone(blocks);
+    const block = findBlock(out, path.key);
+    if (!block)
+        return null;
+    if (path.sub === undefined) {
+        block[path.slug] = structuredClone(value);
+        return out;
+    }
+    const rows = block[path.slug];
+    const row = Array.isArray(rows) ? rows[path.index] : undefined;
+    if (!isObject(row))
+        return null;
+    row[path.sub] = structuredClone(value);
+    return out;
+}

package/dist/lib/guard.d.ts

@@ -3,10 +3,13 @@
  * request that would be refused at save is refused before credits are spent:
  * the request names an entry and a field, the site allows that field, the
  * field is a kind the overlay edits, the entry exists, and the caller may
- * change it.
+ * change it (and for a field inside a blocks field, that it is there and is
+ * text, rich text or a picture).
  */
 import type { RouteContext } from 'emdash';
 import type { VibeEditorOptions } from '../types.js';
+import { type BlockPath, type BlockSchema, type Rules } from './blocks.js';
+import { type BlocksField } from './blockTypes.js';
 import { json } from './respond.js';
 export interface EntryItem {
     id: string;
@@ -19,15 +22,43 @@ export interface EntryItem {
         description?: string | null;
     } | null;
 }
+/**
+ * A field the request may change. `current` is its value as edit mode shows
+ * it and `label` a name for it the AI understands. For a field inside a
+ * blocks field, `blocks` says where in it (see blocks.ts), what a save must
+ * keep to and where its fields are defined; `field` is the
+ * blocks field the entry is written back with.
+ */
 export type Checked = {
     item: EntryItem;
     kind: string;
     collection: string;
     id: string;
     field: string;
+    current: unknown;
+    label: string;
+    blocks?: {
+        path: BlockPath;
+        rules: Rules;
+        schema: BlockSchema;
+        field: BlocksField;
+    };
 };
+export declare const NO_DRAFT = "Innlegget har upubliserte endringer som ikke kan leses her. Rediger i EmDash.";
+export declare const NOT_FOUND = "Fant ikke innholdet.";
+/** The entry as edit mode shows it, read again for a write; or why it can't be. */
+export declare function readEntry(ctx: RouteContext, collection: string, id: string): Promise<EntryItem | {
+    error: string;
+    status: number;
+}>;
 export declare function str(v: unknown): string;
-/** The entry and its field's type, or the answer that refuses the request. */
+/**
+ * The entry and its field's type, or the answer that refuses the request.
+ * A dotted field names a field inside a blocks field: the blocks field must
+ * be allowed, the block must be in the entry, and the field and its type
+ * come from the block type's definition in EmDash; only text, rich text and
+ * pictures can be edited.
+ */
 export declare function checkField(ctx: RouteContext, opts: VibeEditorOptions, input: Record<string, unknown>, kinds: string[]): Promise<Checked | {
     refused: ReturnType<typeof json>;
 }>;

package/dist/lib/guard.js

@@ -1,6 +1,12 @@
 import { isAllowed, mayEdit } from './access.js';
+import { isPath, parsePath, resolve } from './blocks.js';
+import { loadBlockSchema } from './blockTypes.js';
 import { json } from './respond.js';
-const NO_DRAFT = 'Innlegget har upubliserte endringer som ikke kan leses her. Rediger i EmDash.';
+export const NO_DRAFT = 'Innlegget har upubliserte endringer som ikke kan leses her. Rediger i EmDash.';
+export const NOT_FOUND = 'Fant ikke innholdet.';
+const GONE = 'Fant ikke seksjonen. Last siden på nytt.';
+const CANT = 'Dette feltet kan ikke endres her.';
+const NO_TYPES = 'Seksjonene kan ikke redigeres her ennå: nettstedet har ikke oppgitt hvilke felt i dem som kan endres.';
 /**
  * The entry as edit mode shows it. EmDash's get() returns the entry's own row
  * (what is published), while update() writes onto its draft; so a field is
@@ -18,31 +24,77 @@ async function withDraft(ctx, collection, item) {
         return null;
     return { ...item, data: { ...item.data, ...draft.data } };
 }
+/** The entry as edit mode shows it, read again for a write; or why it can't be. */
+export async function readEntry(ctx, collection, id) {
+    const row = (await ctx.content.get(collection, id));
+    if (!row)
+        return { error: NOT_FOUND, status: 404 };
+    return (await withDraft(ctx, collection, row)) || { error: NO_DRAFT, status: 409 };
+}
 export function str(v) {
     return typeof v === 'string' ? v : typeof v === 'number' ? String(v) : '';
 }
-/** The entry and its field's type, or the answer that refuses the request. */
+/**
+ * The entry and its field's type, or the answer that refuses the request.
+ * A dotted field names a field inside a blocks field: the blocks field must
+ * be allowed, the block must be in the entry, and the field and its type
+ * come from the block type's definition in EmDash; only text, rich text and
+ * pictures can be edited.
+ */
 export async function checkField(ctx, opts, input, kinds) {
     const collection = str(input.collection);
     const id = str(input.id);
-    const field = str(input.field);
-    if (!collection || !id || !field)
+    const requested = str(input.field);
+    if (!collection || !id || !requested)
         return { refused: json({ error: 'collection, id og field kreves.' }, 400) };
+    let path;
+    if (isPath(requested)) {
+        const parsed = parsePath(requested);
+        if ('error' in parsed)
+            return { refused: json({ error: parsed.error }, 400) };
+        path = parsed.path;
+    }
+    const field = path ? path.top : requested;
     if (!isAllowed(opts.allow, collection, field))
-        return { refused: json({ error: 'Dette feltet kan ikke endres her.' }, 403) };
+        return { refused: json({ error: CANT }, 403) };
     const schema = await ctx.schema.getCollection(collection);
-    const kind = schema?.fields.find((f) => f.slug === field)?.type || '';
-    if (!kinds.includes(kind))
-        return { refused: json({ error: 'Dette feltet kan ikke endres her.' }, 400) };
+    const schemaField = schema?.fields.find((f) => f.slug === field);
+    const type = schemaField?.type || '';
+    if (path ? type !== 'blocks' : !kinds.includes(type))
+        return { refused: json({ error: CANT }, 400) };
     const row = (await ctx.content.get(collection, id));
     if (!row)
-        return { refused: json({ error: 'Fant ikke innholdet.' }, 404) };
+        return { refused: json({ error: NOT_FOUND }, 404) };
     if (!mayEdit(ctx.user, row))
         return { refused: json({ error: 'Du har ikke tilgang til å endre dette.' }, 403) };
     const item = await withDraft(ctx, collection, row);
     if (!item)
         return { refused: json({ error: NO_DRAFT }, 409) };
-    return { item, kind, collection, id, field };
+    if (!path)
+        return { item, kind: type, collection, id, field, current: item.data[field], label: `${collection}.${field}` };
+    const blockSchema = await loadBlockSchema(opts);
+    if (!blockSchema) {
+        ctx.log.warn("EmDash's block types can't be read from the plugin here: declare the editable fields in vibeEditor({ blocks }), or bundle the plugin (vite.ssr.noExternal)");
+        return { refused: json({ error: NO_TYPES }, 503) };
+    }
+    const found = resolve(item.data[field], path, blockSchema);
+    if ('missing' in found)
+        return { refused: json({ error: GONE }, 409) };
+    if ('refused' in found)
+        return { refused: json({ error: found.refused }, 400) };
+    if (!kinds.includes(found.kind))
+        return { refused: json({ error: found.kind === 'image' ? 'Feltet er et bilde.' : 'Feltet er ikke et bilde.' }, 422) };
+    const blocksField = { slug: field, type, ...(schemaField && 'validation' in schemaField ? { validation: schemaField.validation } : {}) };
+    return {
+        item,
+        kind: found.kind,
+        collection,
+        id,
+        field,
+        current: found.value,
+        label: `${collection}.${found.label}`,
+        blocks: { path, rules: found.rules, schema: blockSchema, field: blocksField },
+    };
 }
 /**
  * The same checks for an entry's SEO block: the request names an entry, the

package/dist/lib/store.d.ts

@@ -3,16 +3,41 @@
  * again with the change, unless it already had unpublished changes of its
  * own: EmDash keeps one draft per entry, and publishing it would publish
  * those too. Then the change waits as a draft and the answer says so.
+ *
+ * The new value is made from the entry as it is just before the write (an
+ * AI call may have taken a while, and someone may have changed the field
+ * meanwhile), by the route's `update`: a picture's alt text goes on the
+ * picture there now, not on the one there when the request came.
+ *
+ * A field inside a blocks field is written as the whole blocks field, with
+ * only that one value changed and every block's key, version and type kept,
+ * after EmDash's own check of blocks values has accepted it (when EmDash's
+ * block types can be read here; see blockTypes.ts).
+ *
+ * EmDash gives plugins no compare-and-set write, so a save made in EmDash's
+ * admin in the few milliseconds between the read and the write can still be
+ * overwritten.
  */
 import type { RouteContext } from 'emdash';
 import type { VibeEditorOptions } from '../types.js';
-import type { Checked } from './guard.js';
+import { type Checked } from './guard.js';
 import { json } from './respond.js';
-/** Stores `value` in the checked field; the answer's body, or the answer for a failed write. */
-export declare function storeField(ctx: RouteContext, opts: VibeEditorOptions, checked: Checked, value: unknown): Promise<{
+/** A route's `update` refusing the change, with the answer's status and message. */
+export declare class Refusal {
+    readonly status: number;
+    readonly error: string;
+    constructor(status: number, error: string);
+}
+type Refused = {
+    refused: ReturnType<typeof json>;
+};
+/**
+ * Stores what `update` makes of the checked field's value now; the answer's
+ * body, or the answer for a refused or failed write.
+ */
+export declare function storeField(ctx: RouteContext, opts: VibeEditorOptions, checked: Checked, update: (current: unknown) => unknown): Promise<{
     ok: true;
     published: boolean;
     warning?: string;
-} | {
-    refused: ReturnType<typeof json>;
-}>;
+} | Refused>;
+export {};