@gobing-ai/knowledge-kit 0.0.37 → 0.1.0

package/plugins/publishings/xiaoyuzhou-pub/src/index.ts

@@ -0,0 +1,174 @@
+/**
+ * xiaoyuzhou-pub — xiaoyuzhou (podcaster.xiaoyuzhoufm.com) podcast publisher plugin surface (task 0295).
+ *
+ * This module is the manifest-facing plugin surface: the declared operation list, the pre-browser
+ * refusal ladder (operation → driver → publishStatus → format → title → body → audio file →
+ * podcastId → duration → cover → unsupported fields — all refused before any browser opens),
+ * `getPublishTransport`, the `--in/--out` IO contract and the CLI `main`. The selectors live in
+ * `src/selectors.ts`, the browser transport and flow in `src/flow.ts`, and the operator session
+ * CLI in `src/profile-check.ts`.
+ *
+ * Evidence: the recovered extension adapter
+ * `.spur/memory/evidence/publish-ready-0288-0297-20261014-01/source/platforms/xiaoyuzhou.js`
+ * (83 lines) pins the field semantics cited below (fill xiaoyuzhou.js:23-78, register map
+ * xiaoyuzhou.js:83) but is a fill-only adapter — no save protocol, no receipt, and it stops
+ * before the publish button (xiaoyuzhou.js:6, 18-19). That button is deliberately never clicked:
+ * this slice saves drafts only.
+ *
+ * publishStatus contract (task 0295 Design freeze): absent defaults to 'draft' and saves through
+ * the exact-visible 保存草稿|保存 candidate (provisional, bounded, fail closed); 'public' and any
+ * unknown value refuse before the browser — final publication on the studio is not evidenced and
+ * not requested by the task AC.
+ */
+import { dirname } from 'node:path';
+import { parseArgs } from 'node:util';
+import { type Content, ContentSchema, type Result, ResultSchema } from '@gobing-ai/kk-core';
+import { type BrowserDriver, FakeBrowserTransport, type PublishTransport } from '@gobing-ai/publish-harness';
+import { createNodeFileSystem } from '@gobing-ai/ts-runtime';
+import { echoError } from '@gobing-ai/ts-utils';
+import { bounded, boundedDetail, errorMessage, fail, XiaoyuzhouBrowserTransport } from './flow';
+import { XYZF_TARGET } from './selectors';
+
+/**
+ * Declared operations (ADR-029 dispatch): the source is a podcast-audio adapter — it runs the
+ * same audio fill for every type and notes it is really a podcast audio upload (xiaoyuzhou.js:7).
+ */
+export const XYZF_OPERATIONS = ['podcast'] as const;
+export type XiaoyuzhouOperation = (typeof XYZF_OPERATIONS)[number];
+
+/**
+ * Resolves the requested operation (`options.operation ?? content.metadata.operation ?? default`)
+ * BEFORE any transport — and therefore before any browser — is resolved. An undeclared value is
+ * refused by name (the source handles podcast audio only, xiaoyuzhou.js:3-7).
+ * @param options - Per-call publish options (`operation`).
+ * @param content - Content whose `metadata.operation` is the fallback source.
+ * @returns The resolved operation, or the refusal message.
+ */
+export function resolveOperation(
+    options?: Record<string, unknown>,
+    content?: Content,
+): { operation: XiaoyuzhouOperation; error?: undefined } | { operation?: undefined; error: string } {
+    const raw = options?.operation ?? content?.metadata?.operation ?? 'podcast';
+    if (typeof raw !== 'string' || !(XYZF_OPERATIONS as readonly string[]).includes(raw)) {
+        return {
+            error: `unsupported operation '${bounded(raw)}' for ${XYZF_TARGET}: expected one of ${XYZF_OPERATIONS.join(', ')}`,
+        };
+    }
+    return { operation: raw as XiaoyuzhouOperation };
+}
+
+/**
+ * Resolves the driver from `options.driver ?? 'script'`. This channel ships one driver and no
+ * `agent` path, so anything else — including a wrong type — is refused by name before a transport
+ * is built.
+ * @param options - Per-call publish options (`driver`).
+ * @returns The resolved driver, or the refusal message.
+ */
+function resolveDriver(
+    options?: Record<string, unknown>,
+): { driver: BrowserDriver; error?: undefined } | { driver?: undefined; error: string } {
+    const raw = options?.driver ?? 'script';
+    if (raw !== 'script') {
+        return {
+            error: `unsupported driver '${bounded(raw)}' for ${XYZF_TARGET}: expected one of script (the xiaoyuzhou-pub browser flow has no agent path)`,
+        };
+    }
+    return { driver: 'script' };
+}
+
+/**
+ * Resolves the channel transport: the publish-harness fake under
+ * `KNOWLEDGE_KIT_PUBLISH_TRANSPORT=fake` (offline, no profile, no browser), otherwise the real
+ * xiaoyuzhou browser transport (`src/flow.ts`). API-only paths never load Playwright eagerly:
+ * the harness launcher imports Playwright dynamically at launch time only.
+ * @param operation - Resolved operation (`podcast`).
+ * @param driver - Resolved driver; only `script` is declared.
+ * @returns The publish transport for this channel.
+ */
+export function getPublishTransport(
+    operation: XiaoyuzhouOperation = 'podcast',
+    driver: BrowserDriver = 'script',
+): PublishTransport {
+    if (process.env.KNOWLEDGE_KIT_PUBLISH_TRANSPORT === 'fake') return new FakeBrowserTransport('script');
+    return new XiaoyuzhouBrowserTransport(operation, driver);
+}
+
+/** Writes the Result to `--out`, creating its directory when the caller named a nested path. */
+async function writePublishResult(outputPath: string, result: Result): Promise<void> {
+    const outDir = dirname(outputPath);
+    if (outDir && outDir !== '.') await createNodeFileSystem().ensureDir(outDir);
+    await createNodeFileSystem().writeFile(outputPath, JSON.stringify(result, null, 2));
+}
+
+/**
+ * The plugin's `--in/--out` contract: validate the Content, resolve **and refuse** the operation
+ * and the driver before any transport exists, then publish through the injected or configured
+ * transport (whose own ladder refuses status/format/payload/audio/show/cover problems — also all
+ * pre-browser).
+ * @param inputPath - Path to the Content JSON.
+ * @param outputPath - Path the Result JSON is written to, on success and on refusal.
+ * @param transport - Optional transport injection for tests and offline runs.
+ */
+export async function processPublishIO(
+    inputPath: string,
+    outputPath: string,
+    transport?: PublishTransport,
+): Promise<void> {
+    await createNodeFileSystem().deleteFile(outputPath);
+    let content: Content;
+    let options: Record<string, unknown> | undefined;
+    try {
+        const raw = JSON.parse(await createNodeFileSystem().readFile(inputPath)) as Record<string, unknown>;
+        content = ContentSchema.parse(raw);
+        if (raw.options !== undefined && typeof raw.options === 'object' && raw.options !== null) {
+            options = raw.options as Record<string, unknown>;
+        }
+    } catch (error: unknown) {
+        const message = boundedDetail(`Invalid Content input: ${errorMessage(error)}`);
+        await writePublishResult(outputPath, fail(XYZF_TARGET, message));
+        throw new Error(message);
+    }
+    const mode = resolveOperation(options, content);
+    if (mode.error !== undefined) {
+        await writePublishResult(outputPath, fail(XYZF_TARGET, mode.error));
+        throw new Error(mode.error);
+    }
+    const driverMode = resolveDriver(options);
+    if (driverMode.error !== undefined) {
+        await writePublishResult(outputPath, fail(XYZF_TARGET, driverMode.error));
+        throw new Error(driverMode.error);
+    }
+    const resolved = transport ?? getPublishTransport(mode.operation, driverMode.driver);
+    const result = ResultSchema.parse(await resolved.publish({ content, options }));
+    await writePublishResult(outputPath, result);
+    if (!result.ok) throw new Error(result.error ?? 'Publish failed');
+}
+
+/**
+ * CLI entry point: `--in <content.json> --out <result.json>`.
+ * @returns Process exit code (0 published, 1 refused or invalid arguments).
+ */
+export async function main(): Promise<number> {
+    let values: { in?: string; out?: string };
+    try {
+        ({ values } = parseArgs({ options: { in: { type: 'string' }, out: { type: 'string' } } }));
+    } catch (error: unknown) {
+        echoError(`Invalid arguments: ${errorMessage(error)}`);
+        return 1;
+    }
+    if (!values.in || !values.out) {
+        echoError('Missing required arguments: --in and --out');
+        return 1;
+    }
+    try {
+        await processPublishIO(values.in, values.out);
+        return 0;
+    } catch (error: unknown) {
+        echoError(`xiaoyuzhou-pub failed: ${boundedDetail(errorMessage(error))}`);
+        return 1;
+    }
+}
+
+if (import.meta.main) {
+    process.exit(await main());
+}

package/plugins/publishings/xiaoyuzhou-pub/src/profile-check.ts

@@ -0,0 +1,26 @@
+/**
+ * xiaoyuzhou profile-session capability (task 0295, Chunk A).
+ *
+ * `login` opens the xiaoyuzhou studio home (https://podcaster.xiaoyuzhoufm.com/, see
+ * `src/selectors.ts`) in a headed browser and resolves only once the site readiness predicate
+ * passes; `check` reopens the profile (headlessly, unless the operator passes `--headed` or the
+ * config sets `checkHeadedOnly`) and reports `verified` or `refused`; `open` just brings the
+ * window up. Arg parsing, profile precedence (`--profile` > `XYZF_PROFILE_DIR` >
+ * `KK_BROWSER_PROFILE_DIR` > `~/.config/kk/browser-profiles/xiaoyuzhou`) and the exit codes
+ * (0 verified, 1 refused, 2 usage error) all live in the shared `runProfileCli`, so the publish
+ * preflight and this CLI apply one gate.
+ *
+ * The readiness predicate observes the site-owned grounded controls (the audio `input#upload`
+ * xiaoyuzhou.js:27, whose absence the source reads as maybe-unlogged xiaoyuzhou.js:28, and the
+ * title `input[name="title"]` xiaoyuzhou.js:55 — see `src/selectors.ts`); an
+ * unsupported-browser page is also not-ready, since the studio officially requires desktop
+ * Chrome 147+ (rerun with KK_BROWSER_CHANNEL=chrome). The login-redirect regex is provisional. A
+ * selector that never attaches is a refusal (`bun plugins/publishings/xiaoyuzhou-pub/src/profile-check.ts login`
+ * is the recovery), never silent success.
+ */
+import { runProfileCli } from '@gobing-ai/publish-harness/browser';
+import { XYZF_CONFIG } from './selectors';
+
+if (import.meta.main) {
+    process.exit(await runProfileCli(XYZF_CONFIG, Bun.argv.slice(2)));
+}

package/plugins/publishings/xiaoyuzhou-pub/src/selectors.ts

@@ -0,0 +1,125 @@
+/**
+ * xiaoyuzhou-pub selectors — every selector/URL/regex constant this channel resolves (task 0295).
+ *
+ * Grounding: the recovered extension adapter
+ * `.spur/memory/evidence/publish-ready-0288-0297-20261014-01/source/platforms/xiaoyuzhou.js` (83
+ * lines, verified 2026-10-15 against the snapshot at
+ * `~xprojects/knowledge-kit/.spur/run/yijianfa-source/platforms/xiaoyuzhou.js`) pins the studio
+ * form controls in its fill (xiaoyuzhou.js:27, 55-56, 65): the audio `input#upload`, the title
+ * `input[name="title"]`, and the Draft.js shownotes editor `div[data-contents="true"]`. Its
+ * mechanism is UI 填表 (xiaoyuzhou.js:3-6): fileDatas[0] → DataTransfer → `files=` +
+ * change/input dispatch (xiaoyuzhou.js:32, 46-50), a bare `.value` title write explicitly flagged
+ * uncertain (逆向存疑) in the source itself (xiaoyuzhou.js:57-58), and a text/html simulated paste into
+ * the Draft.js editor (xiaoyuzhou.js:72-74). The source never saves (不点发布按钮，
+ * xiaoyuzhou.js:6) and marks episode covers unsupported (xiaoyuzhou.js:17).
+ * Anything that evidence does not pin is **Provisional** and fails closed when absent — a missing
+ * control is a loud typed refusal, never a silent no-op or a broad fallback.
+ */
+import { trySelectors } from '@gobing-ai/publish-harness';
+import type { ChannelBrowserConfig } from '@gobing-ai/publish-harness/browser';
+import type { IsAuthenticatedPredicate } from '@gobing-ai/ts-browser-automation';
+
+/** Site-owned target slug; also the profile channel key (`XYZF_PROFILE_DIR`). */
+export const XYZF_TARGET = 'xiaoyuzhou';
+
+/**
+ * Fixed home entry (task 0295 Design freeze): the podcast studio at podcaster.xiaoyuzhoufm.com.
+ * Grounded as the display entry only — the recovered xiaoyuzhou.js never navigates (it fills in
+ * place inside an already-open studio tab).
+ */
+export const XYZF_HOME_URL = 'https://podcaster.xiaoyuzhoufm.com/';
+
+/**
+ * Login/passport redirect marker. **Provisional**: xiaoyuzhou.js never observes a redirect URL;
+ * it only infers logged-out state from the missing audio input (xiaoyuzhou.js:28
+ * 「可能未登录」). The readiness predicate below carries the real gate.
+ */
+export const XYZF_LOGIN_URL_RE = /(passport\.xiaoyuzhoufm\.com|\/(signin|login))/;
+
+/**
+ * Studio unsupported-browser page. **Provisional shape, official requirement**: the 小宇宙
+ * podcaster studio is documented to require desktop Chrome 147+ and serves an
+ * `unsupported-browser` page otherwise (observed bundled Chromium 155.0.8059.40 as
+ * observed-only, never as a support claim). Hitting this page is an environment failure BEFORE
+ * any upload: the operator runs the channel with `KK_BROWSER_CHANNEL=chrome` (the existing
+ * `kkBrowserLauncher` reads it; no Playwright pin change).
+ */
+export const XYZF_UNSUPPORTED_URL_RE = /unsupported-browser/;
+
+/**
+ * Studio form selectors. `audioInput`, `titleInput` and `shownotesEditor` are **Grounded**
+ * (xiaoyuzhou.js:27, 55-56, 65); `coverInput` and `saveButton` are **Provisional** bounded
+ * candidates from the task 0295 Design freeze — fail closed when absent, no broad fallback.
+ */
+export const XYZF_AUDIO_SELECTORS = {
+    /** Audio file input. **Grounded** (xiaoyuzhou.js:27); its absence there reads as maybe-unlogged (xiaoyuzhou.js:28). */
+    audioInput: ['input#upload'],
+    /** Title input. **Grounded** (xiaoyuzhou.js:55-56). */
+    titleInput: ['input[name="title"]'],
+    /** Draft.js shownotes editor. **Grounded** (xiaoyuzhou.js:65); missing there is a typed shownotes failure (xiaoyuzhou.js:66-70). */
+    shownotesEditor: ['div[data-contents="true"]'],
+    /**
+     * Cover file control, scoped to the 上传封面/单集封面 section's file input. **Provisional**:
+     * the vendor marks episode covers unsupported (xiaoyuzhou.js:17) and pins no selector, so
+     * this stays a bounded semantic candidate — never a pretend-provenance claim and never a
+     * silent skip; a missing control is a typed cover failure.
+     */
+    coverInput: ['form:has(div[data-contents="true"]) input[type="file"]:not(#upload)'],
+    /**
+     * The exact-visible draft-save control(s). **Provisional** (task 0295 Design freeze; the
+     * source never saves — xiaoyuzhou.js:6, 18-19); `text-is` exact match, most specific wording
+     * first, no other fallback. Absence is a typed draft-save failure, never a manufactured draft.
+     */
+    saveButton: ['button:text-is("保存草稿")', 'button:text-is("保存")'],
+} as const;
+
+/** Keys of the selector map, for typed probes. */
+export type XiaoyuzhouAudioSelectorKey = keyof typeof XYZF_AUDIO_SELECTORS;
+
+/**
+ * Persisted draft receipt URL shapes. **Provisional**: xiaoyuzhou.js is a fill-only adapter and
+ * never reads a receipt (it stops before publish, xiaoyuzhou.js:6, 18-19); these are the
+ * episode/podcast id-bearing shapes the task 0295 Design freeze names. Only shapes in this list
+ * count as receipts, and only when they were not on screen before the save (fresh-signal rule) —
+ * a toast alone never confirms, and disagreeing fresh ids are an ambiguous typed failure.
+ */
+export const XYZF_RECEIPT_URL_RES = [
+    /podcaster\.xiaoyuzhoufm\.com\/episode\/[0-9a-zA-Z]+/,
+    /xiaoyuzhoufm\.com\/episode\/[0-9a-zA-Z]+/,
+    /podcaster\.xiaoyuzhoufm\.com\/podcast\/[0-9a-zA-Z]+/,
+] as const;
+
+/** Upload/processing ceiling for the audio step (media ceiling — large local files, task 0295 freeze). */
+export const XYZF_UPLOAD_TIMEOUT_MS = 600_000;
+
+/** Login deadline for the operator CLI and the session gate (shared harness default). */
+export const XYZF_LOGIN_TIMEOUT_MS = 180_000;
+
+/**
+ * Xiaoyuzhou-owned readiness predicate: no login redirect, no unsupported-browser environment
+ * page, and the grounded audio input (xiaoyuzhou.js:27) plus title input (xiaoyuzhou.js:55)
+ * attached — xiaoyuzhou.js:28 makes the missing audio input the maybe-unlogged marker. Shared by
+ * the publish preflight and the operator profile CLI, so both apply one gate. The login-redirect
+ * regex is provisional (see `XYZF_LOGIN_URL_RE`); the grounded-control probes carry the real gate.
+ */
+export const isXiaoyuzhouAuthenticated: IsAuthenticatedPredicate = async (page) => {
+    if (XYZF_UNSUPPORTED_URL_RE.test(page.url())) return false;
+    if (XYZF_LOGIN_URL_RE.test(page.url())) return false;
+    const audio = await trySelectors(page, XYZF_AUDIO_SELECTORS.audioInput, { visible: false });
+    if (!audio.found) return false;
+    return (await trySelectors(page, XYZF_AUDIO_SELECTORS.titleInput, { visible: false })).found;
+};
+
+/**
+ * Site-owned config for the shared session check and operator CLI (ADR-032). The check opens the
+ * studio home (`XYZF_HOME_URL`); the manifest `browserSession.homeUrl` is the same entry. The
+ * publish preflight never forwards `checkHeadedOnly`: it is the operator CLI's setting, and a
+ * refusal must never escalate to a headed window on its own.
+ */
+export const XYZF_CONFIG: ChannelBrowserConfig = {
+    channel: XYZF_TARGET,
+    homeUrl: XYZF_HOME_URL,
+    isAuthenticated: isXiaoyuzhouAuthenticated,
+    loginTimeoutMs: XYZF_LOGIN_TIMEOUT_MS,
+    checkHeadedOnly: false,
+};

package/plugins/publishings/xiaoyuzhou-pub/tsconfig.json

@@ -0,0 +1,4 @@
+{
+    "extends": "../../../tooling/typescript/base.json",
+    "include": ["src"]
+}

package/plugins/publishings/zenn-pub/dist/index.js

@@ -11985,6 +11985,83 @@ import { homedir } from "os";
 import { dirname as dirname2, join } from "path";
 import { parseArgs } from "util";
 
+// ../../packages/kk-core/src/content-limits.ts
+var PLATFORM_CONTENT_LIMITS = Object.freeze({
+  schemaVersion: 5,
+  tagLimits: Object.freeze({
+    default: 7,
+    imageText: Object.freeze({
+      instagram: 5,
+      douyin: 5,
+      kuaishou: 4,
+      weixin: 1,
+      xiaohongshu: 10
+    }),
+    shortVideo: Object.freeze({
+      douyin: 5,
+      kuaishou: 4,
+      xiaohongshu: 10,
+      bilibili: 10,
+      zhihu: 5,
+      tiktok: 20,
+      youtube: 60
+    })
+  }),
+  titleCapabilities: Object.freeze({
+    dynamic: Object.freeze({
+      bilibili: Object.freeze({ max: 20, unit: "utf16_code_units" }),
+      zhihu: Object.freeze({ max: 50, unit: "utf16_code_units" }),
+      douban: Object.freeze({ max: 70, unit: "utf16_code_units" }),
+      x: null,
+      threads: null,
+      weibo: null,
+      jike: null,
+      zsxq: null,
+      toutiao: null,
+      juejin: null
+    }),
+    imageText: Object.freeze({
+      xiaohongshu: Object.freeze({ max: 20, unit: "xiaohongshu_title_weighted" }),
+      weixin: Object.freeze({ max: 20, unit: "utf16_code_units" }),
+      douyin: Object.freeze({ max: 20, unit: "utf16_code_units" }),
+      shipinhao: Object.freeze({ max: 22, unit: "utf16_code_units" }),
+      reddit: Object.freeze({ max: 300, unit: "utf16_code_units" })
+    }),
+    article: Object.freeze({
+      juejin: Object.freeze({ max: 100, unit: "utf16_code_units" }),
+      csdn: Object.freeze({ max: 100, unit: "utf16_code_units" }),
+      cnblogs: Object.freeze({ max: 128, unit: "utf16_code_units" }),
+      weibo: Object.freeze({ max: 30, unit: "utf16_code_units" }),
+      sspai: Object.freeze({ max: 80, unit: "utf16_code_units" })
+    }),
+    shortVideo: Object.freeze({
+      shipinhao: Object.freeze({ max: 16, unit: "utf16_code_units" }),
+      douyin: Object.freeze({ max: 30, unit: "utf16_code_units" }),
+      bilibili: Object.freeze({ max: 80, unit: "utf16_code_units" })
+    })
+  }),
+  bodyCapabilities: Object.freeze({
+    dynamic: Object.freeze({
+      threads: Object.freeze({ max: 500, unit: "unicode_code_points", behavior: "split_thread" }),
+      x: Object.freeze({ max: 280, unit: "weighted", behavior: "split_thread" }),
+      weibo: Object.freeze({ max: 2000, unit: "unicode_code_points" }),
+      jike: Object.freeze({ max: 1000, unit: "unicode_code_points" })
+    }),
+    imageText: Object.freeze({
+      xiaohongshu: Object.freeze({ max: 1000, unit: "unicode_code_points" }),
+      douyin: Object.freeze({ max: 1000, unit: "unicode_code_points" })
+    }),
+    article: Object.freeze({
+      wechatmp: Object.freeze({ max: 50000, unit: "unicode_code_points" }),
+      juejin: Object.freeze({ max: 50000, unit: "unicode_code_points" })
+    }),
+    shortVideo: Object.freeze({
+      douyin: Object.freeze({ max: 1000, unit: "unicode_code_points" }),
+      kuaishou: Object.freeze({ max: 1000, unit: "unicode_code_points" }),
+      shipinhao: Object.freeze({ max: 1000, unit: "unicode_code_points" })
+    })
+  })
+});
 // ../../packages/kk-core/src/kinds.ts
 init_zod();
 
@@ -12075,6 +12152,67 @@ var BrowserSessionDescriptorSchema = object({
     }
   }).optional()
 }).strict();
+var ContentCountUnitSchema = _enum([
+  "utf16_code_units",
+  "unicode_code_points",
+  "weighted",
+  "xiaohongshu_title_weighted"
+]);
+var LimitEntrySchema = object({
+  max: number2().int().positive(),
+  unit: ContentCountUnitSchema
+}).strict();
+var PublishingProfileLimitsSchema = object({
+  title: LimitEntrySchema.optional(),
+  body: LimitEntrySchema.optional()
+}).strict();
+var PublishingProfileRequiresSchema = object({
+  cover: boolean2().optional(),
+  orderedImages: boolean2().optional()
+}).strict();
+var PublishingProfileModeBindingSchema = object({
+  metadata: record(string2(), unknown())
+}).strict();
+var PublishingProfileModesSchema = object({
+  draft: PublishingProfileModeBindingSchema.optional(),
+  live: PublishingProfileModeBindingSchema.optional()
+}).strict().superRefine((modes, ctx) => {
+  if (modes.draft === undefined && modes.live === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: 'modes must define at least one of "draft" or "live"'
+    });
+  }
+});
+var PublishingProfileSchema = object({
+  format: string2().min(1),
+  locale: string2().regex(/^(source|[a-z]{2,3}(-[A-Za-z0-9]+)*)$/, {
+    message: 'locale must be "source" or a valid language tag'
+  }),
+  limits: PublishingProfileLimitsSchema.optional(),
+  requires: PublishingProfileRequiresSchema.optional(),
+  modes: PublishingProfileModesSchema
+}).strict();
+var PublishingCapabilitiesSchema = object({
+  defaultProfile: string2().min(1),
+  profiles: record(string2().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/), PublishingProfileSchema)
+}).strict().superRefine((data, ctx) => {
+  const keys = Object.keys(data.profiles);
+  if (keys.length === 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["profiles"],
+      message: "profiles record must be nonempty"
+    });
+  }
+  if (!(data.defaultProfile in data.profiles)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["defaultProfile"],
+      message: `defaultProfile "${data.defaultProfile}" must reference a declared profile`
+    });
+  }
+});
 var PluginManifestSchemaBase = looseObject({
   name: string2().min(1),
   kind: PluginKindSchema,
@@ -12083,23 +12221,31 @@ var PluginManifestSchemaBase = looseObject({
   version: string2().optional(),
   description: string2().optional(),
   operations: record(string2(), PluginOperationSchema).optional(),
-  browserSession: BrowserSessionDescriptorSchema.optional()
+  browserSession: BrowserSessionDescriptorSchema.optional(),
+  publishing: PublishingCapabilitiesSchema.optional()
 });
 var PluginManifestSchema = PluginManifestSchemaBase.superRefine((manifest, ctx) => {
-  if (manifest.browserSession === undefined)
-    return;
-  if (manifest.kind !== "publish") {
-    ctx.addIssue({
-      code: "custom",
-      path: ["browserSession"],
-      message: `browserSession requires kind "publish", not "${manifest.kind}"`
-    });
+  if (manifest.browserSession !== undefined) {
+    if (manifest.kind !== "publish") {
+      ctx.addIssue({
+        code: "custom",
+        path: ["browserSession"],
+        message: `browserSession requires kind "publish", not "${manifest.kind}"`
+      });
+    }
+    if (manifest.check === undefined) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["browserSession"],
+        message: "browserSession requires a check probe entry that owns the session routines"
+      });
+    }
   }
-  if (manifest.check === undefined) {
+  if (manifest.publishing !== undefined && manifest.kind !== "publish") {
     ctx.addIssue({
       code: "custom",
-      path: ["browserSession"],
-      message: "browserSession requires a check probe entry that owns the session routines"
+      path: ["publishing"],
+      message: `publishing requires kind "publish", not "${manifest.kind}"`
     });
   }
 });

package/plugins/publishings/zenn-pub/plugin.json

@@ -3,5 +3,26 @@
     "kind": "publish",
     "entry": "./dist/index.js",
     "version": "1.0.0",
-    "description": "Publish plugin for Zenn (zenn.dev) invoking Zenn CLI via FileCli transport"
+    "description": "Publish plugin for Zenn (zenn.dev) invoking Zenn CLI via FileCli transport",
+    "publishing": {
+        "defaultProfile": "article",
+        "profiles": {
+            "article": {
+                "format": "article",
+                "locale": "ja",
+                "modes": {
+                    "draft": {
+                        "metadata": {
+                            "published": false
+                        }
+                    },
+                    "live": {
+                        "metadata": {
+                            "published": true
+                        }
+                    }
+                }
+            }
+        }
+    }
 }