@gobing-ai/knowledge-kit 0.0.37 → 0.1.1

package/plugins/generations/voxcpm-tts/dist/index.js

@@ -11987,6 +11987,83 @@ import { parseArgs } from "util";
 // ../../plugins/generations/voice-gen/src/index.ts
 import { basename, dirname as dirname2, extname, join as join2, resolve } from "path";
 
+// ../../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();
 
@@ -12077,6 +12154,67 @@ var BrowserSessionDescriptorSchema = object2({
     }
   }).optional()
 }).strict();
+var ContentCountUnitSchema = _enum([
+  "utf16_code_units",
+  "unicode_code_points",
+  "weighted",
+  "xiaohongshu_title_weighted"
+]);
+var LimitEntrySchema = object2({
+  max: number2().int().positive(),
+  unit: ContentCountUnitSchema
+}).strict();
+var PublishingProfileLimitsSchema = object2({
+  title: LimitEntrySchema.optional(),
+  body: LimitEntrySchema.optional()
+}).strict();
+var PublishingProfileRequiresSchema = object2({
+  cover: boolean2().optional(),
+  orderedImages: boolean2().optional()
+}).strict();
+var PublishingProfileModeBindingSchema = object2({
+  metadata: record(string2(), unknown())
+}).strict();
+var PublishingProfileModesSchema = object2({
+  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 = object2({
+  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 = object2({
+  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,
@@ -12085,23 +12223,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}"`
     });
   }
 });
@@ -13549,6 +13695,9 @@ function createVoxCpmClient(options = {}) {
   let renderInFlight;
   let warnedChunk = false;
   let warnedLanguage = false;
+  let warnedInstruct = false;
+  let warnedInstructIgnored = false;
+  let instructSegments = 0;
   const pending = new Map;
   const renderResults = new Map;
   const signalHandlers = new Map;
@@ -13747,6 +13896,14 @@ function createVoxCpmClient(options = {}) {
     }
     const requestedInstruct = body.instruct?.trim();
     if (profile.mode === "instruct") {
+      instructSegments += 1;
+      if (instructSegments > 1) {
+        throw new Error(`voxcpm-tts: profile "${profile.id}" is instruct-mode and pins no speaker \u2014 segment ${instructSegments} would sound like a different person; use a reference/continuation profile (VOXCPM_PROFILES_PATH)`);
+      }
+      if (!warnedInstruct) {
+        warnedInstruct = true;
+        echoError(`voxcpm-tts: profile "${profile.id}" is instruct-mode and pins no speaker \u2014 every request draws a new voice; use a reference/continuation profile for multi-segment episodes`);
+      }
       const instruct = requestedInstruct || profile.instruct;
       if (instruct) {
         return { instruct, normalize: body.normalize ?? true };
@@ -13754,7 +13911,10 @@ function createVoxCpmClient(options = {}) {
       return { normalize: body.normalize ?? true };
     }
     if (requestedInstruct) {
-      throw new Error(`voxcpm-tts: per-request instruct is not supported for "${profile.mode}" mode`);
+      if (!warnedInstructIgnored) {
+        warnedInstructIgnored = true;
+        echoError(`voxcpm-tts: ignoring the per-request instruct on "${profile.mode}" profile "${profile.id}" \u2014 the reference clip defines the voice`);
+      }
     }
     return { normalize: body.normalize ?? true };
   }

package/plugins/generations/voxcpm-tts/scripts/audit-speaker-consistency.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+"""Grade one rendered episode for speaker consistency (音色/音质 uniformity).
+
+Why this exists: a profile whose ``mode`` is ``instruct`` carries no reference audio, so VoxCPM
+samples a speaker per request and a multi-segment episode changes voice between segments. The
+2026-10-15 episode drew 59 different speakers (within-item F0 swing up to 103 Hz) and nobody
+noticed until a human listened. This script makes that measurable.
+
+Usage (needs the plugin venv, which has librosa/numpy):
+
+    plugins/generations/voxcpm-tts/.venv/bin/python \
+        plugins/generations/voxcpm-tts/scripts/audit-speaker-consistency.py <content.json> [more.json ...]
+
+Pass an episode content JSON (grouped per item when the sibling ``sections/<date>/`` dir exists)
+or individual section JSONs. Exit code 1 means the thresholds below were missed.
+
+Thresholds come from the two measured modes (2026-10-15, same three texts):
+  reference/continuation anchored -> F0 spread 22-26 Hz  (one speaker)
+  instruct (random speaker)       -> F0 spread 141 Hz    (three texts, three speakers)
+Grade "pass" needs every item's F0 spread <= 45 Hz and the per-item median <= 30 Hz. Median pitch
+is the honest signal here: it tracks the speaker register, not the sentence's intonation.
+"""
+
+from __future__ import annotations
+
+import json
+import pathlib
+import sys
+import warnings
+
+import librosa
+import numpy as np
+
+warnings.filterwarnings('ignore')
+
+SR = 16000
+MAX_ITEM_F0_SPREAD = 45.0
+MAX_ITEM_MEDIAN_SPREAD = 30.0
+
+
+def measure(content_path: pathlib.Path) -> list[float]:
+    """Per-segment median F0 (Hz) of one rendered Content."""
+    content = json.loads(content_path.read_text())
+    wav_path = content_path.parent / f'{content_path.stem}.wav'
+    audio, _ = librosa.load(str(wav_path), sr=SR, mono=True)
+    medians, offset = [], 0.0
+    for segment in content['metadata']['segments']:
+        start = int(offset * SR)
+        offset += segment['duration']
+        window = audio[start : int(offset * SR)]
+        if len(window) < SR * 0.4:
+            continue
+        f0 = librosa.yin(window, fmin=70, fmax=350, sr=SR)
+        voiced = f0[(f0 > 80) & (f0 < 340)]
+        if len(voiced):
+            medians.append(float(np.median(voiced)))
+    return medians
+
+
+def grouping(content_path: pathlib.Path) -> list[tuple[str, pathlib.Path]]:
+    """Items to grade: the section JSONs when they sit next to the episode, else the file itself."""
+    sections = content_path.parent / 'sections' / content_path.stem.split('_')[0]
+    if content_path.name.endswith('_11_generate_content.json') and sections.is_dir():
+        return sorted((p.stem, p) for p in sections.glob('*.json'))
+    return [(content_path.stem, content_path)]
+
+
+def main(argv: list[str]) -> int:
+    if not argv:
+        print(__doc__.strip().splitlines()[0], file=sys.stderr)
+        print('usage: audit-speaker-consistency.py <content.json> [...]', file=sys.stderr)
+        return 2
+
+    failures: list[str] = []
+    spreads: list[float] = []
+    print(f'{"item":14s} {"segs":>4s} {"medF0":>6s} {"spread":>7s}  verdict')
+    for target in argv:
+        path = pathlib.Path(target)
+        for name, section_path in grouping(path):
+            medians = measure(section_path)
+            if len(medians) < 2:
+                continue
+            spread = max(medians) - min(medians)
+            spreads.append(spread)
+            verdict = 'ok'
+            if spread > MAX_ITEM_F0_SPREAD:
+                verdict = f'unstable (> {MAX_ITEM_F0_SPREAD:.0f} Hz)'
+                failures.append(f'{name}: F0 spread {spread:.0f} Hz across {len(medians)} segments')
+            print(f'{name:14s} {len(medians):4d} {np.median(medians):6.0f} {spread:7.0f}  {verdict}')
+
+    if not spreads:
+        print('no item had enough segments to grade', file=sys.stderr)
+        return 2
+
+    median_spread = float(np.median(spreads))
+    print(f'\nper-item F0 spread: median {median_spread:.0f} Hz, worst {max(spreads):.0f} Hz over {len(spreads)} items')
+    if median_spread > MAX_ITEM_MEDIAN_SPREAD:
+        failures.append(f'median per-item F0 spread {median_spread:.0f} Hz > {MAX_ITEM_MEDIAN_SPREAD:.0f} Hz')
+    if failures:
+        print('FAIL — the episode changes speaker between segments (check the profile mode):')
+        for line in failures:
+            print(f'  - {line}')
+        return 1
+    print('PASS — one speaker across every item')
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv[1:]))

package/plugins/generations/voxcpm-tts/src/voxcpm-client.ts

@@ -273,6 +273,9 @@ export function createVoxCpmClient(options: VoxCpmClientOptions = {}): VoxCpmCli
     let renderInFlight: { id: number; dest: string } | undefined;
     let warnedChunk = false;
     let warnedLanguage = false;
+    let warnedInstruct = false;
+    let warnedInstructIgnored = false;
+    let instructSegments = 0;
     const pending = new Map<number, PendingRequest>();
     const renderResults = new Map<number, Promise<Record<string, unknown>>>();
     const signalHandlers = new Map<NodeJS.Signals, () => void>();
@@ -509,6 +512,22 @@ export function createVoxCpmClient(options: VoxCpmClientOptions = {}): VoxCpmCli
         }
         const requestedInstruct = body.instruct?.trim();
         if (profile.mode === 'instruct') {
+            // Instruct profiles carry no reference audio, so the model samples a speaker per request:
+            // a multi-segment episode then changes voice from segment to segment (20261015: within-item
+            // F0 swing up to 103 Hz, 59 speakers). One segment is still legitimate; a second one is the
+            // defect, so refuse it instead of shipping a voice change.
+            instructSegments += 1;
+            if (instructSegments > 1) {
+                throw new Error(
+                    `voxcpm-tts: profile "${profile.id}" is instruct-mode and pins no speaker — segment ${instructSegments} would sound like a different person; use a reference/continuation profile (VOXCPM_PROFILES_PATH)`,
+                );
+            }
+            if (!warnedInstruct) {
+                warnedInstruct = true;
+                echoError(
+                    `voxcpm-tts: profile "${profile.id}" is instruct-mode and pins no speaker — every request draws a new voice; use a reference/continuation profile for multi-segment episodes`,
+                );
+            }
             const instruct = requestedInstruct || profile.instruct;
             if (instruct) {
                 return { instruct, normalize: body.normalize ?? true };
@@ -516,7 +535,15 @@ export function createVoxCpmClient(options: VoxCpmClientOptions = {}): VoxCpmCli
             return { normalize: body.normalize ?? true };
         }
         if (requestedInstruct) {
-            throw new Error(`voxcpm-tts: per-request instruct is not supported for "${profile.mode}" mode`);
+            // The shared pipeline turns a segment's `emotion` into a per-request instruct, so this is
+            // the normal case for every daily episode. A reference/continuation profile already fixes
+            // the voice: ignoring the instruction beats failing the tier (or re-labelling the clip).
+            if (!warnedInstructIgnored) {
+                warnedInstructIgnored = true;
+                echoError(
+                    `voxcpm-tts: ignoring the per-request instruct on "${profile.mode}" profile "${profile.id}" — the reference clip defines the voice`,
+                );
+            }
         }
         return { normalize: body.normalize ?? true };
     }

package/plugins/ingestions/aihot-ingest/dist/index.js

@@ -12236,6 +12236,83 @@ var init_file_system_node = () => {};
 import { dirname as dirname2 } 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();
 
@@ -12326,6 +12403,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,
@@ -12334,23 +12472,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}"`
     });
   }
 });