@gobing-ai/knowledge-kit 0.0.37 → 0.1.0

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

@@ -0,0 +1,167 @@
+/**
+ * sspai-pub — sspai (sspai.com) Matrix-column article publisher plugin surface (task 0294).
+ *
+ * This module is the manifest-facing plugin surface: the declared operation list, the pre-browser
+ * refusal ladder (operation → driver → publishStatus → title → body → unsupported fields → cover
+ * file — 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/sspai.js` pins the
+ * field semantics cited below (fill sspai.js:23-77, register map sspai.js:82) but is a fill-only
+ * adapter — no save protocol, no receipt, and it stops at the preview control (sspai.js:15-16,
+ * 68-76). That preview is deliberately never clicked: this slice saves drafts only.
+ *
+ * publishStatus contract (task 0294 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/submission on sspai 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, SspaiBrowserTransport } from './flow';
+import { SSPAI_TARGET } from './selectors';
+
+/** Declared operations (ADR-029 dispatch): the source handles article only (sspai.js:24). */
+export const SSPAI_OPERATIONS = ['article'] as const;
+export type SspaiOperation = (typeof SSPAI_OPERATIONS)[number];
+
+/**
+ * Resolves the requested operation. An undeclared value is refused by name, before any transport —
+ * and therefore before any browser — is resolved (the source handles article only, sspai.js:24).
+ * @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: SspaiOperation; error?: undefined } | { operation?: undefined; error: string } {
+    const raw = options?.operation ?? content?.metadata?.operation ?? 'article';
+    if (typeof raw !== 'string' || !(SSPAI_OPERATIONS as readonly string[]).includes(raw)) {
+        return {
+            error: `unsupported operation '${bounded(raw)}' for ${SSPAI_TARGET}: expected one of ${SSPAI_OPERATIONS.join(', ')}`,
+        };
+    }
+    return { operation: raw as SspaiOperation };
+}
+
+/**
+ * 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 ${SSPAI_TARGET}: expected one of script (the sspai-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
+ * sspai browser transport (`src/flow.ts`).
+ * @param operation - Resolved operation (`article`).
+ * @param driver - Resolved driver; only `script` is declared.
+ * @returns The publish transport for this channel.
+ */
+export function getPublishTransport(
+    operation: SspaiOperation = 'article',
+    driver: BrowserDriver = 'script',
+): PublishTransport {
+    if (process.env.KNOWLEDGE_KIT_PUBLISH_TRANSPORT === 'fake') return new FakeBrowserTransport('script');
+    return new SspaiBrowserTransport(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/payload/unsupported-field/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(SSPAI_TARGET, message));
+        throw new Error(message);
+    }
+    const mode = resolveOperation(options, content);
+    if (mode.error !== undefined) {
+        await writePublishResult(outputPath, fail(SSPAI_TARGET, mode.error));
+        throw new Error(mode.error);
+    }
+    const driverMode = resolveDriver(options);
+    if (driverMode.error !== undefined) {
+        await writePublishResult(outputPath, fail(SSPAI_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(`sspai-pub failed: ${boundedDetail(errorMessage(error))}`);
+        return 1;
+    }
+}
+
+if (import.meta.main) {
+    process.exit(await main());
+}

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

@@ -0,0 +1,25 @@
+/**
+ * sspai profile-session capability (task 0294, Chunk A).
+ *
+ * `login` opens the sspai article-editor entry (https://sspai.com/post/write, provisional — 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` > `SSPAI_PROFILE_DIR` >
+ * `KK_BROWSER_PROFILE_DIR` > `~/.config/kk/browser-profiles/sspai`) 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 editor controls (the grounded
+ * `textarea[placeholder="请输入标题..."]` sspai.js:26 and `div[contenteditable="true"]`
+ * sspai.js:59, whose absence sspai.js:60 reads as logged-out — see `src/selectors.ts`); the
+ * login-redirect regex is provisional. A selector that never attaches is a refusal
+ * (`bun plugins/publishings/sspai-pub/src/profile-check.ts login` is the recovery), never
+ * silent success.
+ */
+import { runProfileCli } from '@gobing-ai/publish-harness/browser';
+import { SSPAI_CONFIG } from './selectors';
+
+if (import.meta.main) {
+    process.exit(await runProfileCli(SSPAI_CONFIG, Bun.argv.slice(2)));
+}

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

@@ -0,0 +1,122 @@
+/**
+ * sspai-pub selectors — every selector/URL/regex constant this channel resolves (task 0294).
+ *
+ * Grounding: the recovered extension adapter
+ * `.spur/memory/evidence/publish-ready-0288-0297-20261014-01/source/platforms/sspai.js` (82 lines)
+ * pins the editor controls in its fill (sspai.js:26, 32, 50, 59) and its register map
+ * (sspai.js:82): `textarea[placeholder="请输入标题..."]`, the first
+ * `div[contenteditable="true"]`, and the page's first `input[type="file"]`. Its mechanism is UI
+ * 填表 (sspai.js:5): title textarea value + contenteditable simulated `text/html` paste
+ * (sspai.js:62-65) + cover file-input change dispatch (sspai.js:38-40); `a.editor-extra-button-preview`
+ * (sspai.js:68) is a PREVIEW control only (sspai.js:15-16) and never satisfies a save.
+ * 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 (`SSPAI_PROFILE_DIR`). */
+export const SSPAI_TARGET = 'sspai';
+
+/**
+ * Fixed home entry (task 0294 Design freeze). Grounded as the display entry only — the recovered
+ * sspai.js never navigates (it runs inside an already-open editor tab), so no URL is pinned by it.
+ */
+export const SSPAI_HOME_URL = 'https://sspai.com/';
+
+/**
+ * Article-editor entry where the flow composes. **Provisional**: sspai.js never navigates
+ * (sspai.js fills in place only), and the current editor route is unpinned; `/post/write` is the
+ * historically documented entry (archived official guide, https://sspai.com/post/37790 — draft
+ * saving is documented there historically only, not as current account UI). Every navigation to
+ * this URL fails closed behind the readiness predicate below.
+ */
+export const SSPAI_EDIT_URL = 'https://sspai.com/post/write';
+
+/**
+ * Login/passport redirect marker. **Provisional**: sspai.js never observes a redirect URL; it
+ * only infers logged-out state from the missing editor (sspai.js:60 「可能未登录」).
+ * account.sspai.com is sspai's known SSO entry. The readiness predicate below carries the real
+ * gate — a page body merely mentioning 登录 is never sufficient.
+ */
+export const SSPAI_LOGIN_URL_RE = /(account\.sspai\.com|\/(signin|login))/;
+
+/**
+ * Article-editor selectors. `titleInput`, `bodyEditor`, `coverInput` and `previewButton` are
+ * **Grounded** (sspai.js:26, 50; 59; 32; 68 and the sspai.js:82 register map); `draftSave` is a
+ * **Provisional** bounded candidate from the task 0294 Design freeze — exact visible
+ * 保存草稿|保存, ordered resolution, no broad primary-button fallback, fail closed when absent.
+ */
+export const SSPAI_ARTICLE_SELECTORS = {
+    /** Title textarea. **Grounded** (sspai.js:26, 50, 82). */
+    titleInput: ['textarea[placeholder="请输入标题..."]'],
+    /** Rich-text body editor (contenteditable, first on the editor page). **Grounded** (sspai.js:59, 82); missing there means 未登录 (sspai.js:60). */
+    bodyEditor: ['div[contenteditable="true"]'],
+    /**
+     * Cover file input, scoped to the active article editor's form. **Grounded** that the source
+     * takes the page's first `input[type="file"]` (sspai.js:32), but the task 0294 refine
+     * correction freezes the scoping — a global first file input could target an unrelated
+     * control, and the readback would then "verify" the wrong input. The contenteditable node
+     * itself cannot host the input (the body paste replaces the editor's children), so the
+     * editor-scoped shape is the form that contains the article editor. No page-first fallback.
+     */
+    coverInput: ['form:has(div[contenteditable="true"]) input[type="file"]'],
+    /**
+     * The exact-visible draft-save control(s). **Provisional** (task 0294 Design freeze; the
+     * archived guide documents draft saving historically only — sspai.js never saves);
+     * `text-is` exact match, most specific wording first, no other fallback. Absence is a typed
+     * draft-save failure, never a manufactured draft.
+     */
+    draftSave: ['button:text-is("保存草稿")', 'button:text-is("保存")'],
+    /**
+     * The preview control. **Grounded** (sspai.js:68) — probed read-only for editor-chrome
+     * capability evidence only; it is NEVER clicked in the draft path (sspai.js:15-16: the source
+     * itself stops at preview, and preview is not a save).
+     */
+    previewButton: ['a.editor-extra-button-preview'],
+} as const;
+
+/** Keys of the selector map, for typed probes. */
+export type SspaiArticleSelectorKey = keyof typeof SSPAI_ARTICLE_SELECTORS;
+
+/**
+ * Persisted draft receipt URL shapes. **Provisional**: sspai.js is a fill-only adapter and never
+ * reads a receipt; these are the public-post and drafts-list id shapes the task 0294 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.
+ */
+export const SSPAI_RECEIPT_URL_RES = [/sspai\.com\/post\/\d+/, /sspai\.com\/me\/drafts\/\d+/] as const;
+
+/** Login deadline for the operator CLI and the session gate (shared harness default). */
+export const SSPAI_LOGIN_TIMEOUT_MS = 180_000;
+
+/**
+ * Sspai-owned readiness predicate: no login redirect and the site-owned title textarea (grounded,
+ * sspai.js:26) plus contenteditable editor (grounded, sspai.js:59) attached — sspai.js:60 makes
+ * the missing editor the logged-out marker. Shared by the publish preflight and the operator
+ * profile CLI, so both apply one gate. The login-redirect regex is provisional (see
+ * `SSPAI_LOGIN_URL_RE`); the editor-control probes carry the real gate, and body text mentioning
+ * 登录 is never read.
+ */
+export const isSspaiAuthenticated: IsAuthenticatedPredicate = async (page) => {
+    if (SSPAI_LOGIN_URL_RE.test(page.url())) return false;
+    const title = await trySelectors(page, SSPAI_ARTICLE_SELECTORS.titleInput, { visible: false });
+    if (!title.found) return false;
+    return (await trySelectors(page, SSPAI_ARTICLE_SELECTORS.bodyEditor, { visible: false })).found;
+};
+
+/**
+ * Site-owned config for the shared session check and operator CLI (ADR-032). The check opens the
+ * article-editor entry (see `SSPAI_EDIT_URL`); the manifest `browserSession.homeUrl` stays the
+ * fixed display entry `SSPAI_HOME_URL`. 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 SSPAI_CONFIG: ChannelBrowserConfig = {
+    channel: SSPAI_TARGET,
+    homeUrl: SSPAI_EDIT_URL,
+    isAuthenticated: isSspaiAuthenticated,
+    loginTimeoutMs: SSPAI_LOGIN_TIMEOUT_MS,
+    checkHeadedOnly: false,
+};

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

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

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

@@ -19832,6 +19832,83 @@ var init_runtime_node_bun = __esm(() => {
 import { dirname as dirname4 } 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();
 
@@ -19922,6 +19999,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,
@@ -19930,23 +20068,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}"`
     });
   }
 });
@@ -20569,6 +20715,8 @@ async function ensureProfileDir2(profileDir, headless) {
     throw new BrowserProfileMissingError(profileDir);
   await mkdir2(profileDir, { recursive: true, mode: 448 });
 }
+// ../../packages/publish-harness/src/browser-anti-detection.ts
+var MAX_QUEUED_BYTES = 8 * 1024 * 1024;
 // ../../packages/publish-harness/src/browser.ts
 var DEFAULT_CHECK_TIMEOUT_MS = 30000;
 var DEFAULT_STEP_TIMEOUT_MS = 30000;