feishu-md-sync 0.1.0

package/dist/publish/run-publish.js

@@ -0,0 +1,299 @@
+import { readFile } from 'node:fs/promises';
+import { markdownToFeishuBlocks } from '../markdown/blocks.js';
+import { feishuBlocksToMarkdown } from '../markdown/from-blocks.js';
+import { hashText, readPublishReceipt, writeLocalBaseSnapshot, writePublishReceipt } from '../receipts/publish-receipt.js';
+import { canonicalMarkdownHash } from '../core/markdown-canonical.js';
+import { findPageBlock, renderableDirectChildBlocks } from './block-state.js';
+import { planPublishBlockPatch } from './block-patch-plan.js';
+import { buildPublishPlan } from './publish-plan.js';
+import { resolvePublishTitle } from './title.js';
+import { applyPublishTransformForProfile } from './profile-transform.js';
+export async function runPublish(input) {
+    if (input.write && input.strategy === 'document-replace' && !input.confirmDestructive) {
+        throw new Error('document-replace requires --confirm-destructive in non-interactive mode');
+    }
+    const localSource = await readFile(input.file, 'utf8');
+    const transform = applyPublishTransformForProfile(localSource, input.profile);
+    if (input.target.kind === 'folder' || (input.target.kind === 'wiki' && input.create)) {
+        const title = resolvePublishTitle({
+            sourcePath: input.file,
+            markdown: transform.markdown
+        }).title;
+        const plan = buildPublishPlan({
+            target: input.target,
+            profile: input.profile,
+            localSource,
+            publishDraft: transform.markdown,
+            remoteMarkdown: '',
+            receipt: undefined,
+            transformWarnings: transform.warnings,
+            createDocument: true
+        });
+        if (!input.write)
+            return { mode: 'dry-run', plan };
+        const created = await input.adapter.createDocument({
+            title,
+            markdown: transform.markdown,
+            parentToken: input.target.token
+        });
+        const createdTarget = { kind: 'docx', token: created.documentId };
+        const after = await input.adapter.fetchDocMarkdown({ doc: created.documentId });
+        const localBaseSnapshot = await writeLocalBaseSnapshot({
+            cwd: input.cwd,
+            target: createdTarget,
+            markdown: localSource
+        });
+        await writePublishReceipt({
+            cwd: input.cwd,
+            receipt: {
+                version: 1,
+                target: createdTarget,
+                profile: input.profile,
+                localSourceHash: plan.localSourceHash,
+                publishDraftHash: plan.publishDraftHash,
+                remoteSnapshotHash: hashText(after.markdown),
+                remoteRevision: after.revision ?? created.revision,
+                localBaseSnapshot,
+                updatedAt: new Date().toISOString()
+            }
+        });
+        return {
+            mode: 'write',
+            plan,
+            document: {
+                documentId: created.documentId,
+                url: created.url
+            }
+        };
+    }
+    const remote = await input.adapter.fetchDocMarkdown({ doc: input.target.token });
+    const receipt = await readPublishReceipt({ cwd: input.cwd, target: input.target });
+    const blockPatchDraftMarkdown = markdownBodyForBlockPatch(transform.markdown, remote.markdown);
+    const blockPatch = input.strategy === 'document-replace'
+        ? undefined
+        : await planBlockPatchIfAvailable({
+            adapter: input.adapter,
+            target: input.target,
+            publishDraft: blockPatchDraftMarkdown,
+            warnings: transform.warnings
+        });
+    const plan = buildPublishPlan({
+        target: input.target,
+        profile: input.profile,
+        localSource,
+        publishDraft: transform.markdown,
+        remoteMarkdown: remote.markdown,
+        receipt,
+        transformWarnings: transform.warnings,
+        blockPatch
+    });
+    if (!input.write)
+        return { mode: 'dry-run', plan };
+    if (plan.strategy === 'no-op') {
+        await recordPublishReceipt({
+            cwd: input.cwd,
+            target: input.target,
+            profile: input.profile,
+            localSource,
+            localSourceHash: plan.localSourceHash,
+            publishDraftHash: plan.publishDraftHash,
+            remoteMarkdown: remote.markdown,
+            remoteRevision: remote.revision
+        });
+        return { mode: 'write', plan };
+    }
+    if (plan.strategy === 'block-patch') {
+        if (input.strategy !== 'auto' && input.strategy !== 'block-patch') {
+            throw new Error('block-patch requires --strategy auto or --strategy block-patch');
+        }
+        if (plan.requiresUntrackedRemoteConfirmation && !input.confirmUntrackedRemote) {
+            throw new Error('block-patch for an untracked remote requires --confirm-untracked-remote');
+        }
+        if (plan.requiresCollaborationRiskConfirmation && !input.confirmCollaborationRisk) {
+            throw new Error('block-patch replacing or deleting existing blocks requires --confirm-collaboration-risk');
+        }
+        await applyBlockPatch({
+            adapter: input.adapter,
+            doc: input.target.token,
+            plan,
+            desiredBlocks: markdownToFeishuBlocks(blockPatchDraftMarkdown)
+        });
+        const after = await input.adapter.fetchDocMarkdown({ doc: input.target.token });
+        if (canonicalMarkdownHash(after.markdown) !== canonicalMarkdownHash(transform.markdown)) {
+            throw new Error('block-patch readback verification failed: remote Markdown differs from publish draft');
+        }
+        await recordPublishReceipt({
+            cwd: input.cwd,
+            target: input.target,
+            profile: input.profile,
+            localSource,
+            localSourceHash: plan.localSourceHash,
+            publishDraftHash: plan.publishDraftHash,
+            remoteMarkdown: after.markdown,
+            remoteRevision: after.revision
+        });
+        return { mode: 'write', plan };
+    }
+    if (plan.strategy === 'document-replace') {
+        if (plan.remoteChanged && input.strategy !== 'document-replace') {
+            throw new Error('remote changed since last publish receipt; refusing to write without --strategy document-replace --confirm-destructive');
+        }
+        if (input.strategy !== 'document-replace') {
+            throw new Error('document-replace requires --strategy document-replace');
+        }
+        if (!input.confirmDestructive) {
+            throw new Error('document-replace requires --confirm-destructive in non-interactive mode');
+        }
+        await input.adapter.replaceDocument({ doc: input.target.token, markdown: transform.markdown });
+        const after = await input.adapter.fetchDocMarkdown({ doc: input.target.token });
+        await recordPublishReceipt({
+            cwd: input.cwd,
+            target: input.target,
+            profile: input.profile,
+            localSource,
+            localSourceHash: plan.localSourceHash,
+            publishDraftHash: plan.publishDraftHash,
+            remoteMarkdown: after.markdown,
+            remoteRevision: after.revision
+        });
+        return { mode: 'write', plan };
+    }
+    throw new Error(`Write strategy ${plan.strategy} is not implemented in the first slice.`);
+}
+async function recordPublishReceipt(input) {
+    const localBaseSnapshot = await writeLocalBaseSnapshot({
+        cwd: input.cwd,
+        target: input.target,
+        markdown: input.localSource
+    });
+    await writePublishReceipt({
+        cwd: input.cwd,
+        receipt: {
+            version: 1,
+            target: input.target,
+            profile: input.profile,
+            localSourceHash: input.localSourceHash,
+            publishDraftHash: input.publishDraftHash,
+            remoteSnapshotHash: hashText(input.remoteMarkdown),
+            remoteRevision: input.remoteRevision,
+            localBaseSnapshot,
+            updatedAt: new Date().toISOString()
+        }
+    });
+}
+async function applyBlockPatch(input) {
+    if (!input.plan.blockPatch) {
+        throw new Error('block-patch write is missing a block patch plan');
+    }
+    if (!input.adapter.replaceBlock || !input.adapter.insertBlocksAfter || !input.adapter.deleteBlocks) {
+        throw new Error('Configured Feishu adapter does not support block-patch writes');
+    }
+    for (const operation of input.plan.blockPatch.operations) {
+        if (operation.kind === 'update') {
+            const block = blockAtPath(input.desiredBlocks, operation.path);
+            if (!block)
+                throw new Error(`block-patch update missing desired block at ${operation.path.join('.')}`);
+            await input.adapter.replaceBlock({
+                doc: input.doc,
+                blockId: operation.remoteBlockId,
+                markdown: markdownForWritableBlocks([block])
+            });
+            continue;
+        }
+        if (operation.kind === 'create') {
+            await input.adapter.insertBlocksAfter({
+                doc: input.doc,
+                blockId: operation.insertAfterBlockId,
+                markdown: markdownForWritableBlocks(operation.blocks)
+            });
+            continue;
+        }
+        await input.adapter.deleteBlocks({
+            doc: input.doc,
+            blockIds: operation.blockIds
+        });
+    }
+}
+function blockAtPath(blocks, path) {
+    let currentBlocks = blocks;
+    let current;
+    for (const index of path) {
+        current = currentBlocks[index];
+        if (!current)
+            return undefined;
+        currentBlocks = Array.isArray(current.children) && current.children.every(isFeishuBlock)
+            ? current.children
+            : [];
+    }
+    return current;
+}
+function markdownForWritableBlocks(blocks) {
+    for (const block of blocks) {
+        assertWritableMarkdownBlock(block);
+    }
+    return feishuBlocksToMarkdown(blocks).trim();
+}
+function assertWritableMarkdownBlock(block) {
+    if (!isWritableMarkdownBlockType(block.block_type)) {
+        throw new Error(`block-patch write does not support block_type ${block.block_type}`);
+    }
+    if (Array.isArray(block.children) && block.children.length > 0) {
+        throw new Error(`block-patch write does not support nested children for block_type ${block.block_type}`);
+    }
+    if (block.block_type === 31) {
+        const cells = block.table?.cells ?? [];
+        if (!cells.every(isSimpleTableCellBlock)) {
+            throw new Error('block-patch write only supports simple Markdown table cells');
+        }
+    }
+}
+function isWritableMarkdownBlockType(blockType) {
+    return blockType === 2 || (blockType >= 3 && blockType <= 8) || blockType === 12 || blockType === 13 || blockType === 14 || blockType === 31;
+}
+function isSimpleTableCellBlock(value) {
+    if (!isFeishuBlock(value))
+        return false;
+    return value.block_type === 2 && (!Array.isArray(value.children) || value.children.length === 0);
+}
+function markdownBodyForBlockPatch(publishDraft, remoteMarkdown) {
+    const publishTitle = leadingH1Title(publishDraft);
+    if (!publishTitle)
+        return publishDraft;
+    const remoteTitle = leadingH1Title(remoteMarkdown);
+    if (remoteTitle !== publishTitle)
+        return publishDraft;
+    return stripLeadingH1(publishDraft);
+}
+function leadingH1Title(markdown) {
+    const normalized = markdown.replace(/\r\n/g, '\n').trimStart();
+    const match = normalized.match(/^#\s+(.+?)(?:\n|$)/);
+    return match?.[1]?.trim();
+}
+function stripLeadingH1(markdown) {
+    return markdown
+        .replace(/\r\n/g, '\n')
+        .trimStart()
+        .replace(/^#\s+.+?(?:\n{1,2}|$)/, '')
+        .trimStart();
+}
+async function planBlockPatchIfAvailable(input) {
+    if (input.target.kind !== 'docx' || !input.adapter.fetchDocBlocks) {
+        return undefined;
+    }
+    try {
+        const remote = await input.adapter.fetchDocBlocks({ doc: input.target.token });
+        const pageBlock = findPageBlock(remote.blocks, input.target.token);
+        return planPublishBlockPatch({
+            parentBlockId: pageBlock.block_id,
+            remoteBlocks: renderableDirectChildBlocks(remote.blocks, pageBlock),
+            desiredBlocks: markdownToFeishuBlocks(input.publishDraft)
+        });
+    }
+    catch (error) {
+        input.warnings.push(`block-patch planning unavailable: ${error.message}`);
+        return undefined;
+    }
+}
+function isFeishuBlock(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value) && 'block_type' in value);
+}

package/dist/publish/title.d.ts

@@ -0,0 +1,9 @@
+export type PublishTitleSource = 'option' | 'first H1' | 'file basename';
+export declare function resolvePublishTitle(input: {
+    sourcePath: string;
+    markdown: string;
+    title?: string;
+}): {
+    title: string;
+    titleSource: PublishTitleSource;
+};

package/dist/publish/title.js

@@ -0,0 +1,20 @@
+import path from 'node:path';
+export function resolvePublishTitle(input) {
+    const explicit = clean(input.title);
+    if (explicit)
+        return { title: explicit, titleSource: 'option' };
+    const firstH1 = input.markdown
+        .split(/\r?\n/)
+        .map((line) => line.match(/^#\s+(.+?)\s*$/)?.[1]?.trim())
+        .find((title) => title);
+    if (firstH1)
+        return { title: firstH1, titleSource: 'first H1' };
+    return {
+        title: path.basename(input.sourcePath, path.extname(input.sourcePath)) || 'Untitled',
+        titleSource: 'file basename'
+    };
+}
+function clean(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}

package/dist/pull/run-pull.d.ts

@@ -0,0 +1,23 @@
+import type { FeishuAdapter } from '../adapters/feishu-adapter.js';
+import type { PublishProfileName } from '../profiles/publish-profile.js';
+import { type PublishReceiptTarget } from '../receipts/publish-receipt.js';
+export type RunPullResult = {
+    mode: 'write';
+    target: PublishReceiptTarget;
+    outputPath: string;
+    profile: PublishProfileName;
+    remoteRevision?: string;
+    remoteRawHash: string;
+    outputHash: string;
+    receiptPath?: string;
+    warnings: string[];
+};
+export declare function runPull(input: {
+    cwd: string;
+    target: PublishReceiptTarget;
+    outputPath: string;
+    profile: PublishProfileName;
+    overwrite: boolean;
+    writeReceipt: boolean;
+    adapter: FeishuAdapter;
+}): Promise<RunPullResult>;

package/dist/pull/run-pull.js

@@ -0,0 +1,57 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { normalizeReceiptOutputPath, pullReceiptPath, writePullReceipt } from '../receipts/pull-receipt.js';
+import { hashText } from '../receipts/publish-receipt.js';
+import { applyPullTransformForProfile } from '../transform/zilliz-pull.js';
+export async function runPull(input) {
+    await assertPullOutputWritable(input.outputPath, input.overwrite);
+    const remote = await input.adapter.fetchDocMarkdown({ doc: input.target.token });
+    const transform = applyPullTransformForProfile(remote.markdown, input.profile);
+    await writeFile(input.outputPath, transform.markdown, 'utf8');
+    const written = await readFile(input.outputPath, 'utf8');
+    const outputHash = hashText(transform.markdown);
+    const writtenHash = hashText(written);
+    if (writtenHash !== outputHash) {
+        throw new Error(`pull local write verification failed: expected ${outputHash}, got ${writtenHash}`);
+    }
+    const remoteRawHash = hashText(remote.markdown);
+    const result = {
+        mode: 'write',
+        target: input.target,
+        outputPath: input.outputPath,
+        profile: input.profile,
+        remoteRevision: remote.revision,
+        remoteRawHash,
+        outputHash,
+        warnings: transform.warnings
+    };
+    if (input.writeReceipt) {
+        const receipt = {
+            version: 1,
+            kind: 'pull-snapshot',
+            target: input.target,
+            outputPath: normalizeReceiptOutputPath({ cwd: input.cwd, outputPath: input.outputPath }),
+            profile: input.profile,
+            remoteRevision: remote.revision,
+            remoteRawHash,
+            outputHash,
+            pulledAt: new Date().toISOString()
+        };
+        await writePullReceipt({ cwd: input.cwd, receipt });
+        result.receiptPath = pullReceiptPath({ cwd: input.cwd, outputPath: receipt.outputPath, target: input.target });
+    }
+    return result;
+}
+async function assertPullOutputWritable(outputPath, overwrite) {
+    try {
+        await readFile(outputPath, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    if (!overwrite) {
+        throw new Error(`Refusing to overwrite existing output without --overwrite: ${outputPath}\n` +
+            'Pull writes remote snapshots only; choose a new *.remote.md output or rerun with --overwrite after review.');
+    }
+}

package/dist/receipts/publish-receipt.d.ts

@@ -0,0 +1,49 @@
+import type { PublishProfileName } from '../profiles/publish-profile.js';
+export type PublishReceiptTarget = {
+    kind: 'docx' | 'wiki' | 'folder';
+    token: string;
+};
+export type LocalBaseSnapshot = {
+    path: string;
+    hash: string;
+};
+export type PublishReceipt = {
+    version: 1;
+    target: PublishReceiptTarget;
+    profile: PublishProfileName;
+    localSourceHash: string;
+    publishDraftHash: string;
+    remoteSnapshotHash: string;
+    remoteRevision?: string;
+    localBaseSnapshot?: LocalBaseSnapshot;
+    updatedAt: string;
+};
+export declare function hashText(value: string): string;
+export declare function publishReceiptPath(input: {
+    cwd: string;
+    target: PublishReceiptTarget;
+}): string;
+export declare function baseSnapshotPath(input: {
+    cwd: string;
+    target: PublishReceiptTarget;
+}): string;
+export declare function baseSnapshotRelativePath(input: {
+    target: PublishReceiptTarget;
+}): string;
+export declare function readPublishReceipt(input: {
+    cwd: string;
+    target: PublishReceiptTarget;
+}): Promise<PublishReceipt | undefined>;
+export declare function writePublishReceipt(input: {
+    cwd: string;
+    receipt: PublishReceipt;
+}): Promise<void>;
+export declare function writeLocalBaseSnapshot(input: {
+    cwd: string;
+    target: PublishReceiptTarget;
+    markdown: string;
+}): Promise<LocalBaseSnapshot>;
+export declare function readLocalBaseSnapshot(input: {
+    cwd: string;
+    snapshot: LocalBaseSnapshot;
+}): Promise<string | undefined>;

package/dist/receipts/publish-receipt.js

@@ -0,0 +1,52 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+export function hashText(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+export function publishReceiptPath(input) {
+    return join(input.cwd, '.sync', 'feishu-md-sync', `${input.target.kind}-${input.target.token}.json`);
+}
+export function baseSnapshotPath(input) {
+    return join(input.cwd, baseSnapshotRelativePath({ target: input.target }));
+}
+export function baseSnapshotRelativePath(input) {
+    return join('.sync', 'feishu-md-sync', 'bases', `${input.target.kind}-${input.target.token}-local.md`);
+}
+export async function readPublishReceipt(input) {
+    const path = publishReceiptPath(input);
+    let raw;
+    try {
+        raw = await readFile(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    return JSON.parse(raw);
+}
+export async function writePublishReceipt(input) {
+    const path = publishReceiptPath({ cwd: input.cwd, target: input.receipt.target });
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(input.receipt, null, 2)}\n`, 'utf8');
+}
+export async function writeLocalBaseSnapshot(input) {
+    const path = baseSnapshotPath({ cwd: input.cwd, target: input.target });
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, input.markdown, 'utf8');
+    return {
+        path: baseSnapshotRelativePath({ target: input.target }),
+        hash: hashText(input.markdown)
+    };
+}
+export async function readLocalBaseSnapshot(input) {
+    try {
+        return await readFile(join(input.cwd, input.snapshot.path), 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}

package/dist/receipts/pull-receipt.d.ts

@@ -0,0 +1,31 @@
+import type { PublishProfileName } from '../profiles/publish-profile.js';
+import { type PublishReceiptTarget } from './publish-receipt.js';
+export type PullReceipt = {
+    version: 1;
+    kind: 'pull-snapshot';
+    target: PublishReceiptTarget;
+    outputPath: string;
+    profile: PublishProfileName;
+    remoteRevision?: string;
+    remoteRawHash: string;
+    outputHash: string;
+    pulledAt: string;
+};
+export declare function pullReceiptPath(input: {
+    cwd: string;
+    outputPath: string;
+    target: PublishReceiptTarget;
+}): string;
+export declare function normalizeReceiptOutputPath(input: {
+    cwd: string;
+    outputPath: string;
+}): string;
+export declare function readPullReceipt(input: {
+    cwd: string;
+    outputPath: string;
+    target: PublishReceiptTarget;
+}): Promise<PullReceipt | undefined>;
+export declare function writePullReceipt(input: {
+    cwd: string;
+    receipt: PullReceipt;
+}): Promise<void>;

package/dist/receipts/pull-receipt.js

@@ -0,0 +1,30 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve } from 'node:path';
+import { hashText } from './publish-receipt.js';
+export function pullReceiptPath(input) {
+    const outputKey = hashText(resolve(input.cwd, input.outputPath)).slice(0, 16);
+    return join(input.cwd, '.sync', 'feishu-md-sync', 'pulls', `${outputKey}-${input.target.kind}-${input.target.token}.json`);
+}
+export function normalizeReceiptOutputPath(input) {
+    const absolute = resolve(input.cwd, input.outputPath);
+    const relativePath = relative(input.cwd, absolute);
+    return relativePath.startsWith('..') ? absolute : relativePath;
+}
+export async function readPullReceipt(input) {
+    const path = pullReceiptPath(input);
+    let raw;
+    try {
+        raw = await readFile(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    return JSON.parse(raw);
+}
+export async function writePullReceipt(input) {
+    const path = pullReceiptPath({ cwd: input.cwd, outputPath: input.receipt.outputPath, target: input.receipt.target });
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(input.receipt, null, 2)}\n`, 'utf8');
+}

package/dist/status/run-status.d.ts

@@ -0,0 +1,56 @@
+import type { FeishuAdapter } from '../adapters/feishu-adapter.js';
+import type { PublishProfileName } from '../profiles/publish-profile.js';
+import { type PublishReceipt, type PublishReceiptTarget } from '../receipts/publish-receipt.js';
+export type PublishStatusState = 'untracked' | 'clean' | 'local-changed' | 'remote-changed' | 'diverged';
+export type PublishStatusRecommendationAction = 'no-action' | 'publish-dry-run' | 'pull-review' | 'resolve-divergence' | 'adopt-or-replace';
+export type PublishStatusResult = {
+    target: PublishReceiptTarget;
+    sourcePath: string;
+    profile: PublishProfileName;
+    state: PublishStatusState;
+    localChanged: boolean;
+    remoteChanged: boolean;
+    contentMatchesRemote: boolean;
+    hasReceipt: boolean;
+    receiptPath: string;
+    localSourceHash: string;
+    publishDraftHash: string;
+    publishDraftCanonicalHash: string;
+    remoteSnapshotHash: string;
+    remoteCanonicalHash: string;
+    remoteRevision?: string;
+    transformWarnings: string[];
+    recommendation: {
+        action: PublishStatusRecommendationAction;
+        reason: string;
+    };
+};
+export type PublishStatusContext = {
+    cwd: string;
+    target: PublishReceiptTarget;
+    sourcePath: string;
+    profile: PublishProfileName;
+    localSource: string;
+    publishDraft: string;
+    publishDraftCanonical: string;
+    remoteMarkdown: string;
+    remoteCanonical: string;
+    remoteRevision?: string;
+    receipt: PublishReceipt | undefined;
+    transformWarnings: string[];
+};
+export declare function runStatus(input: {
+    cwd: string;
+    sourcePath: string;
+    target: PublishReceiptTarget;
+    profile: PublishProfileName;
+    adapter: FeishuAdapter;
+}): Promise<PublishStatusResult>;
+export declare function loadPublishStatusContext(input: {
+    cwd: string;
+    sourcePath: string;
+    target: PublishReceiptTarget;
+    profile: PublishProfileName;
+    adapter: FeishuAdapter;
+}): Promise<PublishStatusContext>;
+export declare function statusFromContext(context: PublishStatusContext): PublishStatusResult;