@gobing-ai/knowledge-kit 0.1.13 → 0.1.15

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

@@ -11985,9 +11985,9 @@ var init_file_system_node = () => {};
 
 // ../../plugins/publishings/podcast-pub/src/index.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
 import { readFile } from "fs/promises";
-import { basename, dirname as dirname2, extname as extname2 } from "path";
+import { basename, dirname as dirname2, extname as extname2, join } from "path";
 import { parseArgs } from "util";
 
 // ../../packages/kk-core/src/content-limits.ts
@@ -12231,11 +12231,11 @@ var PluginManifestSchemaBase = looseObject({
 });
 var PluginManifestSchema = PluginManifestSchemaBase.superRefine((manifest, ctx) => {
   if (manifest.browserSession !== undefined) {
-    if (manifest.kind !== "publish") {
+    if (manifest.kind !== "publish" && manifest.kind !== "ingestion") {
       ctx.addIssue({
         code: "custom",
         path: ["browserSession"],
-        message: `browserSession requires kind "publish", not "${manifest.kind}"`
+        message: `browserSession requires kind "publish" or "ingestion", not "${manifest.kind}"`
       });
     }
     if (manifest.check === undefined) {
@@ -14155,6 +14155,101 @@ function mapContentToEpisode(content) {
   };
 }
 
+// ../../plugins/publishings/podcast-pub/src/transcript.ts
+function isMeasured(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function buildTranscriptSegments(segments) {
+  if (segments.length === 0)
+    return;
+  for (const segment of segments) {
+    if (!isMeasured(segment.startSeconds) || segment.startSeconds < 0)
+      return;
+    const text = typeof segment.transcription === "string" ? segment.transcription.trim() : "";
+    if (text.length === 0)
+      return;
+  }
+  for (let index = 1;index < segments.length; index += 1) {
+    if (segments[index].startSeconds <= segments[index - 1].startSeconds) {
+      return;
+    }
+  }
+  const last = segments[segments.length - 1];
+  if (!isMeasured(last.endSeconds) || last.endSeconds <= last.startSeconds)
+    return;
+  return segments.map((segment, index) => ({
+    start: segment.startSeconds,
+    end: index === segments.length - 1 ? segment.endSeconds : segments[index + 1].startSeconds,
+    text: segment.transcription.trim()
+  }));
+}
+function splitTimestamp(seconds) {
+  const totalMs = Math.round((Number.isFinite(seconds) && seconds > 0 ? seconds : 0) * 1000);
+  return {
+    hours: Math.floor(totalMs / 3600000),
+    minutes: String(Math.floor(totalMs % 3600000 / 60000)).padStart(2, "0"),
+    secs: String(Math.floor(totalMs % 60000 / 1000)).padStart(2, "0"),
+    fraction: String(totalMs % 1000).padStart(3, "0")
+  };
+}
+function vttTimestamp(seconds) {
+  const t = splitTimestamp(seconds);
+  return `${String(t.hours).padStart(2, "0")}:${t.minutes}:${t.secs}.${t.fraction}`;
+}
+function escapeVttText(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replace(/\r+/g, "");
+}
+function renderWebVtt(cues) {
+  const lines = ["WEBVTT", ""];
+  for (const cue of cues) {
+    lines.push(`${vttTimestamp(cue.start)} --> ${vttTimestamp(cue.end)}`, escapeVttText(cue.text), "");
+  }
+  return lines.join(`
+`);
+}
+function podcastRecord(metadata) {
+  if (metadata !== null && typeof metadata === "object") {
+    const podcast = metadata.podcast;
+    if (podcast !== null && typeof podcast === "object" && !Array.isArray(podcast)) {
+      return podcast;
+    }
+  }
+  return {};
+}
+function pick3(metadata, key, envValue) {
+  if (Object.hasOwn(metadata, key)) {
+    const value = metadata[key];
+    if (value !== undefined && value !== "")
+      return value;
+  }
+  return envValue !== undefined && envValue !== "" ? envValue : undefined;
+}
+function resolveTranscriptConfig(metadata, env = process.env) {
+  const podcast = podcastRecord(metadata);
+  const rawEnabled = pick3(podcast, "transcriptEnabled", env.PODCAST_PUB_TRANSCRIPT);
+  const enabled = rawEnabled === true || rawEnabled === "true" || rawEnabled === "1";
+  if (rawEnabled !== undefined && !enabled) {
+    if (rawEnabled !== false && rawEnabled !== "false" && rawEnabled !== "0") {
+      return {
+        error: `invalid transcript enable flag "${String(rawEnabled)}": expected PODCAST_PUB_TRANSCRIPT or metadata.podcast.transcriptEnabled to be true or false`
+      };
+    }
+  }
+  const rawUrl = pick3(podcast, "transcriptUrl", env.PODCAST_PUB_TRANSCRIPT_URL);
+  if (rawUrl === undefined)
+    return { config: { enabled } };
+  const url = typeof rawUrl === "string" ? rawUrl.trim() : String(rawUrl).trim();
+  if (!url.startsWith("https://")) {
+    return {
+      error: `invalid transcript URL "${url}": microfeed hosts only HTTPS transcript files (set metadata.podcast.transcriptUrl or PODCAST_PUB_TRANSCRIPT_URL to an https:// URL)`
+    };
+  }
+  return { config: { enabled, url } };
+}
+function transcriptReferences(url) {
+  return [{ url, type: "text/vtt", language: "zh-cn" }];
+}
+
 // ../../plugins/publishings/podcast-pub/src/index.ts
 function publicItemUrl(item, itemId, client) {
   const microfeed = item?._microfeed;
@@ -14301,6 +14396,48 @@ function resolveAssemblyOptions(options) {
   }
   return { assembly };
 }
+function prepareTranscript(metadata, warnings, emit = (message) => warn(message, warnings)) {
+  const config = resolveTranscriptConfig(metadata);
+  if ("error" in config)
+    throw new Error(config.error);
+  if (!config.config.enabled)
+    return;
+  if (!config.config.url) {
+    emit("transcript skipped: PODCAST_PUB_TRANSCRIPT is on but no transcriptUrl was provided");
+    return;
+  }
+  const meta = metadata ?? {};
+  const segments = Array.isArray(meta.segments) ? meta.segments.map((s) => ({
+    startSeconds: typeof s.startSeconds === "number" ? s.startSeconds : undefined,
+    endSeconds: typeof s.endSeconds === "number" ? s.endSeconds : undefined,
+    transcription: typeof s.transcription === "string" ? s.transcription : undefined
+  })) : [];
+  const cues = buildTranscriptSegments(segments);
+  if (!cues) {
+    emit("transcript skipped: no measured absolute offsets recorded for every segment (concat does not record startSeconds/endSeconds yet); summed per-clip durations are never used for cue timing");
+    return;
+  }
+  const source = (() => {
+    for (const key of ["mp3Path", "audioPath", "audioFile"]) {
+      const value = meta[key];
+      if (typeof value === "string" && value.trim().length > 0)
+        return value.trim();
+    }
+    return;
+  })();
+  if (!source) {
+    emit("transcript skipped: no local mp3Path/audioPath/audioFile to anchor the .vtt artifact next to");
+    return;
+  }
+  const vttPath = `${join(dirname2(source), basename(source).replace(/\.[^.]+$/, ""))}.vtt`;
+  try {
+    writeFileSync2(vttPath, renderWebVtt(cues), "utf-8");
+  } catch (error) {
+    emit(`transcript skipped: could not write ${vttPath} (${error instanceof Error ? error.message : String(error)})`);
+    return;
+  }
+  return transcriptReferences(config.config.url);
+}
 function audioAttachment(audio, mediaUrl, sizeInBytes, durationSeconds) {
   return {
     category: "audio",
@@ -14316,6 +14453,7 @@ function episodeExtras(episode, seo) {
     ...episode.datePublishedMs !== undefined ? { date_published_ms: episode.datePublishedMs } : {},
     ...episode.link ? { url: episode.link } : {},
     _microfeed: {
+      ...episode.transcripts ? { podcast: { transcripts: episode.transcripts } } : {},
       "itunes:episodeType": episode.itunes?.episodeType ?? "full",
       ...episode.itunes?.title ? { "itunes:title": episode.itunes.title } : {},
       ...episode.itunes?.season !== undefined ? { "itunes:season": episode.itunes.season } : {},
@@ -14478,6 +14616,11 @@ async function publishEpisode(client, payload, options) {
   if (!policy.ok)
     return fail2(policy.error);
   const fields = policy.fields;
+  try {
+    episode.transcripts = prepareTranscript(content.metadata, fields.warnings);
+  } catch (error) {
+    return fail2(`Invalid transcript config: ${error instanceof Error ? error.message : String(error)}`);
+  }
   let social;
   try {
     social = await resolveSocialImage(client, fields, fields.warnings);

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

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
-import { readFileSync } from 'node:fs';
+import { readFileSync, writeFileSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
-import { basename, dirname, extname } from 'node:path';
+import { basename, dirname, extname, join } from 'node:path';
 import { parseArgs } from 'node:util';
 import { type Content, ContentSchema, DocListSchema, type Result, ResultSchema } from '@gobing-ai/kk-core';
 import { FakeFileCliTransport, type PublishTransport, type PublishTransportPayload } from '@gobing-ai/publish-harness';
@@ -25,6 +25,7 @@ import {
     warn,
 } from './seo';
 import { renderShowNotesMarkdown, type ShowNotesRenderOptions } from './show-notes';
+import { buildTranscriptSegments, renderWebVtt, resolveTranscriptConfig, transcriptReferences } from './transcript';
 
 /** Result target name for this plugin. */
 /**
@@ -261,6 +262,65 @@ function resolveAssemblyOptions(options: PodcastPubOptions): { assembly: Assembl
     return { assembly };
 }
 
+/**
+ * Builds `_microfeed.podcast.transcripts` behind `PODCAST_PUB_TRANSCRIPT` (design
+ * docs/design/podcast-transcript.md): builds the WebVTT from `metadata.segments[]` measured
+ * absolute offsets and writes it as a local dry-run artifact next to the episode's audio
+ * source — transcript files are never uploaded here (microfeed hosts only already-external
+ * HTTPS URLs). Inert today: the audio chain records no measured offsets, so this returns
+ * undefined and the payload omits `podcast` entirely so a later update cannot erase a stored
+ * transcript list.
+ */
+function prepareTranscript(
+    metadata: Record<string, unknown> | undefined,
+    warnings: string[],
+    emit: (message: string) => void = (message) => warn(message, warnings),
+): EpisodeMapping['transcripts'] {
+    const config = resolveTranscriptConfig(metadata);
+    if ('error' in config) throw new Error(config.error);
+    if (!config.config.enabled) return undefined;
+    if (!config.config.url) {
+        emit('transcript skipped: PODCAST_PUB_TRANSCRIPT is on but no transcriptUrl was provided');
+        return undefined;
+    }
+    const meta = metadata ?? {};
+    const segments = Array.isArray(meta.segments)
+        ? (meta.segments as Array<Record<string, unknown>>).map((s) => ({
+              startSeconds: typeof s.startSeconds === 'number' ? s.startSeconds : undefined,
+              endSeconds: typeof s.endSeconds === 'number' ? s.endSeconds : undefined,
+              transcription: typeof s.transcription === 'string' ? s.transcription : undefined,
+          }))
+        : [];
+    const cues = buildTranscriptSegments(segments);
+    if (!cues) {
+        emit(
+            'transcript skipped: no measured absolute offsets recorded for every segment (concat does not record startSeconds/endSeconds yet); summed per-clip durations are never used for cue timing',
+        );
+        return undefined;
+    }
+    const source = (() => {
+        for (const key of ['mp3Path', 'audioPath', 'audioFile'] as const) {
+            const value = meta[key];
+            if (typeof value === 'string' && value.trim().length > 0) return value.trim();
+        }
+        return undefined;
+    })();
+    if (!source) {
+        emit('transcript skipped: no local mp3Path/audioPath/audioFile to anchor the .vtt artifact next to');
+        return undefined;
+    }
+    const vttPath = `${join(dirname(source), basename(source).replace(/\.[^.]+$/, ''))}.vtt`;
+    try {
+        writeFileSync(vttPath, renderWebVtt(cues), 'utf-8');
+    } catch (error: unknown) {
+        emit(
+            `transcript skipped: could not write ${vttPath} (${error instanceof Error ? error.message : String(error)})`,
+        );
+        return undefined;
+    }
+    return transcriptReferences(config.config.url);
+}
+
 /** Builds the RSS-enclosure attachment from the presigned-upload media URL (design D2). */
 function audioAttachment(
     audio: ReturnType<typeof mapContentToEpisode>['audio'],
@@ -284,6 +344,7 @@ function episodeExtras(episode: EpisodeMapping, seo?: SeoBlock): MicrofeedItemIn
         ...(episode.datePublishedMs !== undefined ? { date_published_ms: episode.datePublishedMs } : {}),
         ...(episode.link ? { url: episode.link } : {}),
         _microfeed: {
+            ...(episode.transcripts ? { podcast: { transcripts: episode.transcripts } } : {}),
             'itunes:episodeType': episode.itunes?.episodeType ?? 'full',
             ...(episode.itunes?.title ? { 'itunes:title': episode.itunes.title } : {}),
             ...(episode.itunes?.season !== undefined ? { 'itunes:season': episode.itunes.season } : {}),
@@ -499,6 +560,14 @@ async function publishEpisode(
     const policy = prepareEpisodeFields(episode, content.metadata ?? {}, seoConfig.config);
     if (!policy.ok) return fail(policy.error);
     const fields = policy.fields;
+    // Transcript (PODCAST_PUB_TRANSCRIPT): built and written to disk before any create call so
+    // the `_microfeed` payload in both create branches carries the same field when it exists.
+    try {
+        episode.transcripts = prepareTranscript(content.metadata, fields.warnings);
+    } catch (error: unknown) {
+        return fail(`Invalid transcript config: ${error instanceof Error ? error.message : String(error)}`);
+    }
+
     let social: NonNullable<SeoBlock['social_image']> | undefined;
     try {
         social = await resolveSocialImage(client, fields, fields.warnings);

package/plugins/publishings/podcast-pub/src/map.ts

@@ -1,6 +1,7 @@
 import { extname } from 'node:path';
 import type { Content } from '@gobing-ai/kk-core';
 import { renderShowNotesHtml } from './show-notes';
+import type { TranscriptReference } from './transcript';
 
 /** Local-cover extensions accepted from `metadata.coverImage` (R4); anything else is rejected. */
 const COVER_EXTS = new Set(['.png', '.jpg', '.jpeg', '.webp', '.gif']);
@@ -25,6 +26,8 @@ export interface EpisodeMapping {
     datePublishedMs?: number;
     /** Optional public link for the episode (`metadata.articleUrl` → microfeed `url`). */
     link?: string;
+    /** Transcript references (`PODCAST_PUB_TRANSCRIPT`, wired in index.ts; empty when disabled/unavailable). */
+    transcripts?: TranscriptReference[];
     /** Podcast-directory fields (`metadata.itunes`) passed through to `_microfeed`. */
     itunes?: {
         title?: string;

package/plugins/publishings/podcast-pub/src/transcript.ts

@@ -0,0 +1,195 @@
+/**
+ * Transcript cues from real measured data (design docs/design/podcast-transcript.md).
+ *
+ * Inert today: the audio chain (voice-gen `concatWavs`, the daily sectioned ffmpeg join,
+ * `dailyIntro`) does not record measured absolute offsets, and the intro sting plus
+ * inter-segment silences are invisible to per-clip durations — so summed durations cannot be
+ * used for cue timing. A transcript is built ONLY when every segment carries a measured
+ * absolute `startSeconds`/`endSeconds` recorded against the final mixed episode plus real
+ * text. Until the concat step records those offsets, this returns undefined and the publish
+ * payload simply omits `_microfeed.podcast.transcripts`. Nothing here touches the network.
+ */
+
+/**
+ * One segment from `metadata.segments[]` in **final-mixed-episode coordinates** (the shape the
+ * concat step must record; per-clip `duration` values are deliberately NOT an input here —
+ * summed durations never derive cue starts).
+ */
+export interface TranscriptSegmentInput {
+    /** Measured absolute start of the segment's speech in the mixed episode. */
+    startSeconds?: number;
+    /**
+     * Optional measured absolute end. Only the LAST segment's `endSeconds` is read (the final
+     * cue boundary); earlier cue ends come from the next segment's measured start.
+     */
+    endSeconds?: number;
+    transcription?: string;
+}
+
+/** Framed cue: `[start, end)` seconds in final-mixed coordinates and the caption text. */
+export interface TranscriptCue {
+    start: number;
+    end: number;
+    text: string;
+}
+
+function isMeasured(value: unknown): value is number {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+
+/**
+ * Builds one cue per segment ONLY when every segment carries a measured absolute
+ * `startSeconds` (strictly increasing) and the LAST segment carries a measured absolute
+ * `endSeconds`, plus a non-empty transcription on every segment. Each cue start is the
+ * segment's own measured offset — never a sum of per-clip durations — and each end is the
+ * next measured boundary. Any missing/invalid value discards the whole transcript
+ * (undefined); a partially timed transcript is not shippable.
+ */
+export function buildTranscriptSegments(segments: TranscriptSegmentInput[]): TranscriptCue[] | undefined {
+    if (segments.length === 0) return undefined;
+    for (const segment of segments) {
+        if (!isMeasured(segment.startSeconds) || segment.startSeconds < 0) return undefined;
+        const text = typeof segment.transcription === 'string' ? segment.transcription.trim() : '';
+        if (text.length === 0) return undefined;
+    }
+    for (let index = 1; index < segments.length; index += 1) {
+        if (
+            (segments[index] as { startSeconds: number }).startSeconds <=
+            (segments[index - 1] as { startSeconds: number }).startSeconds
+        ) {
+            return undefined;
+        }
+    }
+    const last = segments[segments.length - 1] as { startSeconds: number; endSeconds?: number };
+    if (!isMeasured(last.endSeconds) || last.endSeconds <= last.startSeconds) return undefined;
+    return segments.map((segment, index) => ({
+        start: segment.startSeconds as number,
+        end:
+            index === segments.length - 1
+                ? (segment.endSeconds as number)
+                : (segments[index + 1] as { startSeconds: number }).startSeconds,
+        text: (segment.transcription as string).trim(),
+    }));
+}
+
+function splitTimestamp(seconds: number): { hours: number; minutes: string; secs: string; fraction: string } {
+    const totalMs = Math.round((Number.isFinite(seconds) && seconds > 0 ? seconds : 0) * 1000);
+    return {
+        hours: Math.floor(totalMs / 3_600_000),
+        minutes: String(Math.floor((totalMs % 3_600_000) / 60_000)).padStart(2, '0'),
+        secs: String(Math.floor((totalMs % 60_000) / 1000)).padStart(2, '0'),
+        fraction: String(totalMs % 1000).padStart(3, '0'),
+    };
+}
+
+/** `HH:MM:SS.mmm` — WebVTT requires two-digit hours. */
+function vttTimestamp(seconds: number): string {
+    const t = splitTimestamp(seconds);
+    return `${String(t.hours).padStart(2, '0')}:${t.minutes}:${t.secs}.${t.fraction}`;
+}
+
+/** `HH:MM:SS,mmm` — SubRip twin of the VTT stamp with a comma decimal separator. */
+function srtTimestamp(seconds: number): string {
+    const t = splitTimestamp(seconds);
+    return `${String(t.hours).padStart(2, '0')}:${t.minutes}:${t.secs},${t.fraction}`;
+}
+
+/**
+ * WebVTT escaping per spec: `&` first, then `<`/`>` (the two characters a WebVTT parser treats
+ * as markup). CR characters are dropped so text lines stay inline.
+ */
+function escapeVttText(text: string): string {
+    return text.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replace(/\r+/g, '');
+}
+
+/** WebVTT document: `WEBVTT` header, then one cue per segment (overview cues omitted deliberately). */
+export function renderWebVtt(cues: TranscriptCue[]): string {
+    const lines = ['WEBVTT', ''];
+    for (const cue of cues) {
+        lines.push(`${vttTimestamp(cue.start)} --> ${vttTimestamp(cue.end)}`, escapeVttText(cue.text), '');
+    }
+    return lines.join('\n');
+}
+
+/** SubRip twin of {@link renderWebVtt}: numbered cues, `,` decimal separator, no header. */
+export function renderSrt(cues: TranscriptCue[]): string {
+    const lines: string[] = [];
+    let number = 1;
+    for (const cue of cues) {
+        lines.push(
+            String(number),
+            `${srtTimestamp(cue.start)} --> ${srtTimestamp(cue.end)}`,
+            escapeVttText(cue.text),
+            '',
+        );
+        number += 1;
+    }
+    return lines.join('\n');
+}
+
+/** microfeed 1.0.13 transcript entry: HTTPS URL only, `text/plain` is not accepted. */
+export interface TranscriptReference {
+    url: string;
+    type: 'text/vtt' | 'application/x-subrip';
+    language: string;
+}
+
+export interface TranscriptConfig {
+    /** `PODCAST_PUB_TRANSCRIPT` / `metadata.podcast.transcriptEnabled` — default false. */
+    enabled: boolean;
+    /** Already-hosted HTTPS URL (`PODCAST_PUB_TRANSCRIPT_URL` / `metadata.podcast.transcriptUrl`). */
+    url?: string;
+}
+
+function podcastRecord(metadata: Record<string, unknown> | undefined): Record<string, unknown> {
+    if (metadata !== null && typeof metadata === 'object') {
+        const podcast = metadata.podcast;
+        if (podcast !== null && typeof podcast === 'object' && !Array.isArray(podcast)) {
+            return podcast as Record<string, unknown>;
+        }
+    }
+    return {};
+}
+
+function pick(metadata: Record<string, unknown>, key: string, envValue: string | undefined): unknown {
+    if (Object.hasOwn(metadata, key)) {
+        const value = metadata[key];
+        if (value !== undefined && value !== '') return value;
+    }
+    return envValue !== undefined && envValue !== '' ? envValue : undefined;
+}
+
+/**
+ * `metadata.podcast.*` wins over env (the plugin's established precedence, `src/seo.ts` pick).
+ * A non-HTTPS or non-string URL fails loud before any request; flag on without a URL disables
+ * the transcript with a warning instead of an error.
+ */
+export function resolveTranscriptConfig(
+    metadata: Record<string, unknown> | undefined,
+    env: NodeJS.ProcessEnv = process.env,
+): { config: TranscriptConfig } | { error: string } {
+    const podcast = podcastRecord(metadata);
+    const rawEnabled = pick(podcast, 'transcriptEnabled', env.PODCAST_PUB_TRANSCRIPT);
+    const enabled = rawEnabled === true || rawEnabled === 'true' || rawEnabled === '1';
+    if (rawEnabled !== undefined && !enabled) {
+        if (rawEnabled !== false && rawEnabled !== 'false' && rawEnabled !== '0') {
+            return {
+                error: `invalid transcript enable flag "${String(rawEnabled)}": expected PODCAST_PUB_TRANSCRIPT or metadata.podcast.transcriptEnabled to be true or false`,
+            };
+        }
+    }
+    const rawUrl = pick(podcast, 'transcriptUrl', env.PODCAST_PUB_TRANSCRIPT_URL);
+    if (rawUrl === undefined) return { config: { enabled } };
+    const url = typeof rawUrl === 'string' ? rawUrl.trim() : String(rawUrl).trim();
+    if (!url.startsWith('https://')) {
+        return {
+            error: `invalid transcript URL "${url}": microfeed hosts only HTTPS transcript files (set metadata.podcast.transcriptUrl or PODCAST_PUB_TRANSCRIPT_URL to an https:// URL)`,
+        };
+    }
+    return { config: { enabled, url } };
+}
+
+/** The `_microfeed.podcast.transcripts` value for a real hosted VTT (zh-cn episodes). */
+export function transcriptReferences(url: string): TranscriptReference[] {
+    return [{ url, type: 'text/vtt', language: 'zh-cn' }];
+}

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

@@ -12225,11 +12225,11 @@ var PluginManifestSchemaBase = looseObject({
 });
 var PluginManifestSchema = PluginManifestSchemaBase.superRefine((manifest, ctx) => {
   if (manifest.browserSession !== undefined) {
-    if (manifest.kind !== "publish") {
+    if (manifest.kind !== "publish" && manifest.kind !== "ingestion") {
       ctx.addIssue({
         code: "custom",
         path: ["browserSession"],
-        message: `browserSession requires kind "publish", not "${manifest.kind}"`
+        message: `browserSession requires kind "publish" or "ingestion", not "${manifest.kind}"`
       });
     }
     if (manifest.check === undefined) {

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

@@ -20073,11 +20073,11 @@ var PluginManifestSchemaBase = looseObject({
 });
 var PluginManifestSchema = PluginManifestSchemaBase.superRefine((manifest, ctx) => {
   if (manifest.browserSession !== undefined) {
-    if (manifest.kind !== "publish") {
+    if (manifest.kind !== "publish" && manifest.kind !== "ingestion") {
       ctx.addIssue({
         code: "custom",
         path: ["browserSession"],
-        message: `browserSession requires kind "publish", not "${manifest.kind}"`
+        message: `browserSession requires kind "publish" or "ingestion", not "${manifest.kind}"`
       });
     }
     if (manifest.check === undefined) {
@@ -20683,10 +20683,12 @@ function sha256Hex(value) {
 var DEFAULT_BOT_PROFILE_ROOT = join4(homedir4(), ".config", "kk", "browser-profiles");
 class BotError extends Error {
   code;
-  constructor(code, message) {
+  details;
+  constructor(code, message, details = {}) {
     super(message);
     this.name = "BotError";
     this.code = code;
+    this.details = details;
   }
 }
 // ../../packages/publish-harness/src/profile-dir.ts

package/plugins/publishings/shipinhao-pub/dist/profile-check.js

@@ -20097,10 +20097,12 @@ function normalizeSessionIdentity(value) {
 }
 class BotError extends Error {
   code;
-  constructor(code, message) {
+  details;
+  constructor(code, message, details = {}) {
     super(message);
     this.name = "BotError";
     this.code = code;
+    this.details = details;
   }
 }
 // ../../packages/publish-harness/src/index.ts

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

@@ -20073,11 +20073,11 @@ var PluginManifestSchemaBase = looseObject({
 });
 var PluginManifestSchema = PluginManifestSchemaBase.superRefine((manifest, ctx) => {
   if (manifest.browserSession !== undefined) {
-    if (manifest.kind !== "publish") {
+    if (manifest.kind !== "publish" && manifest.kind !== "ingestion") {
       ctx.addIssue({
         code: "custom",
         path: ["browserSession"],
-        message: `browserSession requires kind "publish", not "${manifest.kind}"`
+        message: `browserSession requires kind "publish" or "ingestion", not "${manifest.kind}"`
       });
     }
     if (manifest.check === undefined) {
@@ -20707,10 +20707,12 @@ function sha256Hex(value) {
 var DEFAULT_BOT_PROFILE_ROOT = join4(homedir4(), ".config", "kk", "browser-profiles");
 class BotError extends Error {
   code;
-  constructor(code, message) {
+  details;
+  constructor(code, message, details = {}) {
     super(message);
     this.name = "BotError";
     this.code = code;
+    this.details = details;
   }
 }
 // ../../packages/publish-harness/src/profile-dir.ts

package/plugins/publishings/sspai-pub/dist/profile-check.js

@@ -20097,10 +20097,12 @@ function normalizeSessionIdentity(value) {
 }
 class BotError extends Error {
   code;
-  constructor(code, message) {
+  details;
+  constructor(code, message, details = {}) {
     super(message);
     this.name = "BotError";
     this.code = code;
+    this.details = details;
   }
 }
 // ../../packages/publish-harness/src/index.ts

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

@@ -20073,11 +20073,11 @@ var PluginManifestSchemaBase = looseObject({
 });
 var PluginManifestSchema = PluginManifestSchemaBase.superRefine((manifest, ctx) => {
   if (manifest.browserSession !== undefined) {
-    if (manifest.kind !== "publish") {
+    if (manifest.kind !== "publish" && manifest.kind !== "ingestion") {
       ctx.addIssue({
         code: "custom",
         path: ["browserSession"],
-        message: `browserSession requires kind "publish", not "${manifest.kind}"`
+        message: `browserSession requires kind "publish" or "ingestion", not "${manifest.kind}"`
       });
     }
     if (manifest.check === undefined) {
@@ -20701,10 +20701,12 @@ function sha256Hex(value) {
 var DEFAULT_BOT_PROFILE_ROOT = join4(homedir4(), ".config", "kk", "browser-profiles");
 class BotError extends Error {
   code;
-  constructor(code, message) {
+  details;
+  constructor(code, message, details = {}) {
     super(message);
     this.name = "BotError";
     this.code = code;
+    this.details = details;
   }
 }
 // ../../packages/publish-harness/src/profile-dir.ts

package/plugins/publishings/substack-pub/dist/profile-check.js

@@ -20369,10 +20369,12 @@ function normalizeSessionIdentity(value) {
 }
 class BotError extends Error {
   code;
-  constructor(code, message) {
+  details;
+  constructor(code, message, details = {}) {
     super(message);
     this.name = "BotError";
     this.code = code;
+    this.details = details;
   }
 }
 // ../../packages/publish-harness/src/index.ts
@@ -20948,11 +20950,11 @@ var PluginManifestSchemaBase = looseObject({
 });
 var PluginManifestSchema = PluginManifestSchemaBase.superRefine((manifest, ctx) => {
   if (manifest.browserSession !== undefined) {
-    if (manifest.kind !== "publish") {
+    if (manifest.kind !== "publish" && manifest.kind !== "ingestion") {
       ctx.addIssue({
         code: "custom",
         path: ["browserSession"],
-        message: `browserSession requires kind "publish", not "${manifest.kind}"`
+        message: `browserSession requires kind "publish" or "ingestion", not "${manifest.kind}"`
       });
     }
     if (manifest.check === undefined) {