@deployxai/dxc 0.3.2 → 0.3.3

package/dist/chunks/chunk-6JNQZHAQ.js

@@ -1,1522 +0,0 @@
-import { createRequire as __dxcCreateRequire } from "node:module"; const require = __dxcCreateRequire(import.meta.url);
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __esm = (fn, res, err) => function __init() {
-  if (err) throw err[0];
-  try {
-    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-  } catch (e) {
-    throw err = [e], e;
-  }
-};
-var __commonJS = (cb, mod) => function __require2() {
-  try {
-    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  } catch (e) {
-    throw mod = 0, e;
-  }
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// packages/contracts/src/content-knowledge.ts
-import { z } from "zod";
-var CONTENT_KNOWLEDGE_SCHEMA_VERSION = "2";
-var CONTENT_KNOWLEDGE_EMBEDDING_MODEL = "Xenova/bge-small-zh-v1.5";
-var CONTENT_KNOWLEDGE_EMBEDDING_REVISION = "75c43b069aac4d136ba6bc1122f995fedcfd2781";
-var CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS = 512;
-var CONTENT_KNOWLEDGE_EMBEDDING_QUANTIZATION = "q8";
-var CONTENT_KNOWLEDGE_CHUNKER_VERSION = "dxc-markdown-chunker@3";
-var contentKnowledgeSearchModeSchema = z.enum(["hybrid", "lexical", "semantic"]);
-var contentKnowledgeQuoteStatusSchema = z.enum(["active", "archived"]);
-var contentKnowledgeQuoteOriginSchema = z.enum(["original", "third-party"]);
-var contentKnowledgeQuoteVerbatimUseSchema = z.enum([
-  "original",
-  "needs-verification",
-  "permitted",
-  "do-not-use-verbatim"
-]);
-var contentKnowledgeModelSchema = z.object({
-  dimensions: z.literal(CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS),
-  id: z.literal(CONTENT_KNOWLEDGE_EMBEDDING_MODEL),
-  quantization: z.literal(CONTENT_KNOWLEDGE_EMBEDDING_QUANTIZATION),
-  revision: z.literal(CONTENT_KNOWLEDGE_EMBEDDING_REVISION)
-}).strict();
-var contentKnowledgeArticleSummarySchema = z.object({
-  articleId: z.uuid(),
-  chunkCount: z.number().int().positive(),
-  contentSha256: z.string().regex(/^[a-f0-9]{64}$/u),
-  importedAt: z.iso.datetime(),
-  sourceLabel: z.string().trim().min(1).max(255),
-  title: z.string().trim().min(1).max(300),
-  updatedAt: z.iso.datetime()
-}).strict();
-var contentKnowledgeImportItemSchema = z.object({
-  article: contentKnowledgeArticleSummarySchema,
-  semanticIndexed: z.boolean(),
-  status: z.enum(["created", "updated", "unchanged"])
-}).strict();
-var contentKnowledgeImportSkippedItemSchema = z.object({
-  code: z.enum(["DXC_KNOWLEDGE_ARTICLE_INVALID", "DXC_KNOWLEDGE_FILE_TOO_LARGE"]),
-  message: z.string().trim().min(1),
-  sourceLabel: z.string().trim().min(1).max(255)
-}).strict();
-var contentKnowledgeImportResultSchema = z.object({
-  command: z.literal("knowledge.import"),
-  data: z.object({
-    imported: z.array(contentKnowledgeImportItemSchema),
-    model: contentKnowledgeModelSchema.nullable(),
-    skipped: z.array(contentKnowledgeImportSkippedItemSchema)
-  }).strict(),
-  ok: z.literal(true)
-}).strict();
-var contentKnowledgeMatchLaneSchema = z.enum(["lexical", "semantic"]);
-var contentKnowledgeSearchItemBaseSchema = z.object({
-  lanes: z.array(contentKnowledgeMatchLaneSchema).min(1).max(2),
-  rank: z.number().int().positive().max(20),
-  snippet: z.string().trim().min(1).max(420)
-}).strict();
-var contentKnowledgeHistorySearchItemSchema = contentKnowledgeSearchItemBaseSchema.extend({
-  articleId: z.uuid(),
-  chunkId: z.uuid(),
-  chunkSha256: z.string().regex(/^[a-f0-9]{64}$/u),
-  heading: z.string().trim().min(1).max(300).nullable(),
-  ordinal: z.number().int().nonnegative(),
-  sourceType: z.literal("history-article"),
-  sourceLabel: z.string().trim().min(1).max(255),
-  title: z.string().trim().min(1).max(300)
-});
-var contentKnowledgeQuoteSearchItemSchema = contentKnowledgeSearchItemBaseSchema.extend({
-  attribution: z.string().trim().min(1).max(300).nullable(),
-  contentSha256: z.string().regex(/^[a-f0-9]{64}$/u),
-  origin: contentKnowledgeQuoteOriginSchema,
-  quoteId: z.uuid(),
-  sourceLabel: z.string().trim().min(1).max(300).nullable(),
-  sourceType: z.literal("quote"),
-  status: contentKnowledgeQuoteStatusSchema,
-  tags: z.array(z.string().trim().min(1).max(80)).max(20),
-  verbatimUse: contentKnowledgeQuoteVerbatimUseSchema
-});
-var contentKnowledgeSearchItemSchema = z.discriminatedUnion("sourceType", [
-  contentKnowledgeHistorySearchItemSchema,
-  contentKnowledgeQuoteSearchItemSchema
-]);
-var contentKnowledgeQuoteSummarySchema = z.object({
-  activeCount: z.number().int().nonnegative(),
-  archivedCount: z.number().int().nonnegative(),
-  sourceInitialized: z.boolean(),
-  sourcePath: z.literal("~/Documents/DxC/\u91D1\u53E5\u5E93.md"),
-  sourceSha256: z.string().regex(/^[a-f0-9]{64}$/u).nullable()
-}).strict();
-var contentKnowledgeQuoteRecordSchema = z.object({
-  attribution: z.string().trim().min(1).max(300).nullable(),
-  origin: contentKnowledgeQuoteOriginSchema,
-  quoteId: z.uuid(),
-  source: z.string().trim().min(1).max(300).nullable(),
-  status: contentKnowledgeQuoteStatusSchema,
-  tags: z.array(z.string().trim().min(1).max(80)).max(20),
-  text: z.string().trim().min(1).max(2e3),
-  verbatimUse: contentKnowledgeQuoteVerbatimUseSchema
-}).strict();
-var contentKnowledgeQuoteListResultSchema = z.object({
-  command: z.literal("knowledge.quotes.list"),
-  data: z.object({ quotes: z.array(contentKnowledgeQuoteRecordSchema).max(5e3) }).strict(),
-  ok: z.literal(true)
-}).strict();
-var contentKnowledgeQuoteMutationResultSchema = z.object({
-  command: z.enum([
-    "knowledge.quotes.add",
-    "knowledge.quotes.update",
-    "knowledge.quotes.archive"
-  ]),
-  data: z.object({ quote: contentKnowledgeQuoteRecordSchema, synced: z.literal(true) }).strict(),
-  ok: z.literal(true)
-}).strict();
-var contentKnowledgeQuoteStatusResultSchema = z.object({
-  command: z.literal("knowledge.quotes.status"),
-  data: contentKnowledgeQuoteSummarySchema,
-  ok: z.literal(true)
-}).strict();
-var contentKnowledgeSearchItemLegacySchema = z.object({
-  articleId: z.uuid(),
-  chunkId: z.uuid(),
-  chunkSha256: z.string().regex(/^[a-f0-9]{64}$/u),
-  heading: z.string().trim().min(1).max(300).nullable(),
-  lanes: z.array(contentKnowledgeMatchLaneSchema).min(1).max(2),
-  ordinal: z.number().int().nonnegative(),
-  rank: z.number().int().positive().max(20),
-  snippet: z.string().trim().min(1).max(420),
-  sourceLabel: z.string().trim().min(1).max(255),
-  title: z.string().trim().min(1).max(300)
-}).strict();
-var contentKnowledgeSearchResultSchema = z.object({
-  command: z.literal("knowledge.search"),
-  data: z.object({
-    mode: contentKnowledgeSearchModeSchema,
-    model: contentKnowledgeModelSchema.nullable(),
-    query: z.string().trim().min(1).max(500),
-    results: z.array(contentKnowledgeSearchItemSchema).max(20)
-  }).strict(),
-  ok: z.literal(true)
-}).strict();
-var contentKnowledgeStatusResultSchema = z.object({
-  command: z.literal("knowledge.status"),
-  data: z.object({
-    articleCount: z.number().int().nonnegative(),
-    chunkCount: z.number().int().nonnegative(),
-    databasePath: z.literal("~/.dxc/content-memory.sqlite"),
-    model: contentKnowledgeModelSchema,
-    modelCached: z.boolean(),
-    semanticIndexedChunkCount: z.number().int().nonnegative(),
-    quotes: contentKnowledgeQuoteSummarySchema
-  }).strict(),
-  ok: z.literal(true)
-}).strict();
-var contentKnowledgeRemoveResultSchema = z.object({
-  command: z.literal("knowledge.remove"),
-  data: z.object({
-    articleId: z.uuid(),
-    removed: z.boolean()
-  }).strict(),
-  ok: z.literal(true)
-}).strict();
-var contentKnowledgeCommandSchema = z.enum([
-  "knowledge.import",
-  "knowledge.remove",
-  "knowledge.search",
-  "knowledge.status",
-  "knowledge.quotes.add",
-  "knowledge.quotes.archive",
-  "knowledge.quotes.list",
-  "knowledge.quotes.status",
-  "knowledge.quotes.update"
-]);
-var contentKnowledgeErrorResultSchema = z.object({
-  command: contentKnowledgeCommandSchema,
-  error: z.object({
-    code: z.enum([
-      "DXC_KNOWLEDGE_ARTICLE_INVALID",
-      "DXC_KNOWLEDGE_DIRECTORY_INVALID",
-      "DXC_KNOWLEDGE_DIRECTORY_TOO_LARGE",
-      "DXC_KNOWLEDGE_FILE_TOO_LARGE",
-      "DXC_KNOWLEDGE_INPUT_NOT_FOUND",
-      "DXC_KNOWLEDGE_IO_FAILED",
-      "DXC_KNOWLEDGE_MODEL_FAILED",
-      "DXC_KNOWLEDGE_QUERY_INVALID",
-      "DXC_KNOWLEDGE_QUOTE_INVALID",
-      "DXC_KNOWLEDGE_QUOTE_SOURCE_NOT_INITIALIZED",
-      "DXC_KNOWLEDGE_SCHEMA_UNSUPPORTED",
-      "DXC_KNOWLEDGE_SEMANTIC_NOT_READY",
-      "DXC_KNOWLEDGE_STATE_INVALID"
-    ]),
-    details: z.object({
-      nextAction: z.object({
-        choices: z.array(
-          z.object({
-            choiceId: z.string().regex(/^knowledge-choice1_[A-Za-z0-9_-]+\.[a-f0-9]{32}$/u),
-            label: z.string().trim().min(1).max(120)
-          }).strict()
-        ).length(2),
-        purpose: z.literal("knowledge-model-unavailable"),
-        type: z.literal("select-choice")
-      }).strict()
-    }).strict().optional(),
-    message: z.string().trim().min(1)
-  }).strict(),
-  ok: z.literal(false)
-}).strict();
-
-// packages/contracts/src/index.ts
-import { z as z6 } from "zod";
-
-// packages/contracts/src/publishing.ts
-import { z as z2 } from "zod";
-var sha256Schema = z2.string().regex(/^[a-f0-9]{64}$/u);
-var wechatTemplateIdSchema = z2.enum([
-  "wechat-minimal@1",
-  "wechat-academic-paper@1",
-  "wechat-aurora-glass@1",
-  "wechat-bauhaus@1",
-  "wechat-cyberpunk-neon@1",
-  "wechat-knowledge-base@1",
-  "wechat-luxury-gold@1",
-  "wechat-morandi-forest@1",
-  "wechat-neo-brutalism@1",
-  "wechat-receipt@1",
-  "wechat-sunset-film@1"
-]);
-var publishingUploadKindSchema = z2.enum(["article-source", "cover-image", "inline-image"]);
-var publishingUploadMediaTypeSchema = z2.enum([
-  "text/markdown",
-  "text/plain",
-  "image/jpeg",
-  "image/png"
-]);
-var createPublishingUploadRequestSchema = z2.object({
-  fileName: z2.string().trim().min(1).max(160),
-  kind: publishingUploadKindSchema,
-  mediaType: publishingUploadMediaTypeSchema,
-  sha256: sha256Schema,
-  size: z2.number().int().positive().max(5 * 1024 * 1024)
-}).strict().superRefine((value, context) => {
-  if (value.kind === "article-source" && value.mediaType !== "text/markdown" && value.mediaType !== "text/plain") {
-    context.addIssue({
-      code: "custom",
-      message: "article source requires a text media type",
-      path: ["mediaType"]
-    });
-  }
-  if ((value.kind === "cover-image" || value.kind === "inline-image") && value.mediaType !== "image/jpeg" && value.mediaType !== "image/png") {
-    context.addIssue({
-      code: "custom",
-      message: "image upload requires a supported image media type",
-      path: ["mediaType"]
-    });
-  }
-  if (value.kind === "article-source" && value.size > 512 * 1024) {
-    context.addIssue({
-      code: "custom",
-      message: "article source exceeds the maximum size",
-      path: ["size"]
-    });
-  }
-  if (value.kind === "inline-image" && value.size >= 1024 * 1024) {
-    context.addIssue({
-      code: "custom",
-      message: "inline image must be smaller than 1 MiB",
-      path: ["size"]
-    });
-  }
-});
-var publishingUploadSessionSchema = z2.object({
-  expiresAt: z2.iso.datetime(),
-  id: z2.uuid(),
-  kind: publishingUploadKindSchema,
-  uploadUrl: z2.url()
-}).strict();
-var publishingUploadReceiptSchema = z2.object({
-  id: z2.uuid(),
-  sha256: sha256Schema,
-  size: z2.number().int().positive().max(5 * 1024 * 1024),
-  status: z2.literal("UPLOADED")
-}).strict();
-var createPublishingArticleRequestSchema = z2.object({
-  coverUploadId: z2.uuid(),
-  inlineAssets: z2.array(
-    z2.object({
-      logicalPath: z2.string().trim().min(1).max(240),
-      uploadId: z2.uuid()
-    }).strict()
-  ).max(20).optional(),
-  sourceUploadId: z2.uuid()
-}).strict().superRefine((value, context) => {
-  const inlineAssets = value.inlineAssets ?? [];
-  const logicalPaths = inlineAssets.map((asset) => asset.logicalPath);
-  const uploadIds = inlineAssets.map((asset) => asset.uploadId);
-  if (new Set(logicalPaths).size !== logicalPaths.length) {
-    context.addIssue({
-      code: "custom",
-      message: "inline asset logical paths must be unique",
-      path: ["inlineAssets"]
-    });
-  }
-  if (new Set(uploadIds).size !== uploadIds.length) {
-    context.addIssue({
-      code: "custom",
-      message: "inline asset uploads must be unique",
-      path: ["inlineAssets"]
-    });
-  }
-});
-var publishingInlineAssetSchema = z2.object({
-  logicalPath: z2.string().trim().min(1).max(240),
-  mediaType: z2.enum(["image/jpeg", "image/png"]),
-  sha256: sha256Schema
-}).strict();
-var publishingArticleSchema = z2.object({
-  cover: z2.object({
-    height: z2.number().int().positive().max(12e3),
-    mediaType: z2.enum(["image/jpeg", "image/png"]),
-    width: z2.number().int().positive().max(12e3)
-  }).strict(),
-  coverHash: sha256Schema,
-  createdAt: z2.iso.datetime(),
-  id: z2.uuid(),
-  inlineAssets: z2.array(publishingInlineAssetSchema).max(20).default([]),
-  sourceHash: sha256Schema
-}).strict();
-var createPublishingRenderSnapshotRequestSchema = z2.object({
-  title: z2.string().trim().min(1).max(64).optional()
-}).strict();
-var publishingPreflightIssueSchema = z2.object({
-  code: z2.string().trim().min(1),
-  message: z2.string().trim().min(1),
-  path: z2.string().trim().min(1).optional()
-}).strict();
-var publishingPreflightSchema = z2.object({
-  errors: z2.array(publishingPreflightIssueSchema),
-  metrics: z2.object({
-    digestCharacters: z2.number().int().nonnegative(),
-    externalLinkCount: z2.number().int().nonnegative(),
-    htmlCharacters: z2.number().int().nonnegative(),
-    imageCount: z2.number().int().nonnegative(),
-    tableCount: z2.number().int().nonnegative()
-  }).strict(),
-  ok: z2.boolean(),
-  warnings: z2.array(publishingPreflightIssueSchema)
-}).strict();
-var publishingRenderSnapshotSchema = z2.object({
-  articleId: z2.uuid(),
-  assetManifestHash: sha256Schema,
-  author: z2.string().trim().min(1).max(16),
-  commentsEnabled: z2.boolean(),
-  coverHash: sha256Schema,
-  createdAt: z2.iso.datetime(),
-  digest: z2.string().trim().min(1).max(120),
-  htmlHash: sha256Schema,
-  id: z2.uuid(),
-  inlineAssets: z2.array(publishingInlineAssetSchema).max(20).default([]),
-  preflight: publishingPreflightSchema,
-  rendererVersion: z2.string().trim().min(1),
-  snapshotHash: sha256Schema,
-  sourceHash: sha256Schema,
-  templateId: wechatTemplateIdSchema,
-  title: z2.string().trim().min(1).max(32)
-}).strict();
-var createPublishingPreviewLinkRequestSchema = z2.object({
-  snapshotHash: sha256Schema
-}).strict();
-var publishingPreviewLinkSchema = z2.object({
-  createdAt: z2.iso.datetime().optional(),
-  expiresAt: z2.iso.datetime(),
-  expiresInSeconds: z2.number().int().positive().max(24 * 60 * 60).optional(),
-  snapshotHash: sha256Schema,
-  url: z2.url()
-}).strict();
-var publishingPreviewSelectionStateSchema = z2.object({
-  rootSnapshotHash: sha256Schema,
-  rootSnapshotId: z2.uuid(),
-  selectedSnapshotHash: sha256Schema,
-  selectedSnapshotId: z2.uuid(),
-  selectionRevision: z2.number().int().nonnegative(),
-  templateId: wechatTemplateIdSchema,
-  updatedAt: z2.iso.datetime(),
-  viewed: z2.boolean(),
-  viewedAt: z2.iso.datetime().nullable()
-}).strict();
-var createPublishingApprovalRequestSchema = z2.object({
-  accountId: z2.uuid(),
-  confirmed: z2.literal(true),
-  snapshotHash: sha256Schema
-}).strict();
-var publishingApprovalSchema = z2.object({
-  accountId: z2.uuid(),
-  confirmedAt: z2.iso.datetime(),
-  id: z2.uuid(),
-  rootSnapshotHash: sha256Schema,
-  rootSnapshotId: z2.uuid(),
-  selectedSnapshotHash: sha256Schema,
-  selectedSnapshotId: z2.uuid(),
-  templateId: wechatTemplateIdSchema
-}).strict();
-var createPublishingDraftIntentRequestSchema = z2.object({
-  approvalId: z2.uuid(),
-  previousIntentId: z2.uuid().optional()
-}).strict();
-var publishingDraftStatusSchema = z2.enum([
-  "QUEUED",
-  "PREPARING",
-  "UPLOADING_ASSETS",
-  "ASSET_UPLOAD_UNVERIFIED",
-  "CREATING_DRAFT",
-  "VERIFYING",
-  "SUCCEEDED",
-  "CREATED_UNVERIFIED",
-  "FAILED"
-]);
-var publishingDraftIntentSchema = z2.object({
-  accountId: z2.uuid(),
-  approvalId: z2.uuid(),
-  createdAt: z2.iso.datetime(),
-  errorCode: z2.string().trim().min(1).optional(),
-  id: z2.uuid(),
-  mediaId: z2.string().trim().min(1).max(128).optional(),
-  progress: z2.object({
-    label: z2.string().trim().min(1).max(40),
-    message: z2.string().trim().min(1).max(300),
-    nextAction: z2.string().trim().min(1).max(300),
-    pollAfterSeconds: z2.number().int().positive().max(60).nullable(),
-    terminal: z2.boolean()
-  }).strict(),
-  snapshotHash: sha256Schema,
-  status: publishingDraftStatusSchema,
-  updatedAt: z2.iso.datetime(),
-  verification: z2.object({
-    authorMatched: z2.boolean(),
-    contentMatched: z2.boolean(),
-    digestMatched: z2.boolean(),
-    titleMatched: z2.boolean()
-  }).strict().optional()
-}).strict();
-var publishingDraftIntentResponseSchema = z2.object({
-  intent: publishingDraftIntentSchema
-}).strict();
-var publishingDraftAttentionDiagnosticsSchema = z2.object({
-  errorCode: z2.string().trim().min(1).optional(),
-  intentId: z2.uuid(),
-  reason: z2.object({
-    message: z2.string().trim().min(1).max(500),
-    nextAction: z2.string().trim().min(1).max(500),
-    phase: z2.enum([
-      "preparation",
-      "asset-upload",
-      "draft-create",
-      "draft-readback",
-      "verification",
-      "unknown"
-    ]),
-    retryAllowed: z2.boolean()
-  }).strict(),
-  status: publishingDraftStatusSchema,
-  verification: z2.object({
-    authorMatched: z2.boolean(),
-    coverMatched: z2.boolean().nullable(),
-    contentMatched: z2.boolean(),
-    digestMatched: z2.boolean(),
-    firstDifference: z2.enum(["image-count", "image-identity", "image-order", "text"]).nullable().optional(),
-    imageMismatches: z2.array(
-      z2.object({
-        actualIndex: z2.number().int().nonnegative().optional(),
-        expectedIndex: z2.number().int().nonnegative().optional(),
-        kind: z2.enum(["identity", "missing", "order", "unexpected"]),
-        logicalPath: z2.string().trim().min(1).max(240).optional(),
-        role: z2.enum(["cover", "inline-image"])
-      }).strict()
-    ).max(41),
-    titleMatched: z2.boolean()
-  }).strict().optional()
-}).strict();
-
-// packages/contracts/src/content-workflow.ts
-import { z as z3 } from "zod";
-var CONTENT_WORKFLOW_ID = "dxc-article@1";
-var CONTENT_PROFILE_QUESTIONNAIRE_VERSION = "dxc-onboarding@1";
-var CONTENT_ARTIFACT_KINDS = [
-  "research",
-  "brief",
-  "outline",
-  "article",
-  "titles",
-  "visual-plan",
-  "quality-review",
-  "delivery"
-];
-var contentArtifactKindSchema = z3.enum(CONTENT_ARTIFACT_KINDS);
-var DXC_STAGE_SKILL_NAMES = [
-  "dxc-research",
-  "dxc-content-brief",
-  "dxc-article-outline",
-  "dxc-article-write",
-  "dxc-title-write",
-  "dxc-visual-plan",
-  "dxc-content-review",
-  "dxc-wechat-publisher"
-];
-var dxcStageSkillNameSchema = z3.enum(DXC_STAGE_SKILL_NAMES);
-var CONTENT_STAGE_DEFINITIONS = {
-  article: {
-    inputs: { optional: [], required: ["research", "brief", "outline"] },
-    output: "article",
-    skill: "dxc-article-write",
-    stage: "article"
-  },
-  brief: {
-    inputs: { optional: [], required: ["research"] },
-    output: "brief",
-    skill: "dxc-content-brief",
-    stage: "brief"
-  },
-  delivery: {
-    inputs: { optional: [], required: ["article", "titles", "visual-plan", "quality-review"] },
-    output: "delivery",
-    skill: "dxc-wechat-publisher",
-    stage: "delivery"
-  },
-  outline: {
-    inputs: { optional: [], required: ["research", "brief"] },
-    output: "outline",
-    skill: "dxc-article-outline",
-    stage: "outline"
-  },
-  "quality-review": {
-    inputs: { optional: ["visual-plan"], required: ["research", "article", "titles"] },
-    output: "quality-review",
-    skill: "dxc-content-review",
-    stage: "quality-review"
-  },
-  research: {
-    inputs: { optional: [], required: [] },
-    output: "research",
-    skill: "dxc-research",
-    stage: "research"
-  },
-  titles: {
-    inputs: { optional: ["brief"], required: ["article"] },
-    output: "titles",
-    skill: "dxc-title-write",
-    stage: "titles"
-  },
-  "visual-plan": {
-    inputs: { optional: ["outline"], required: ["article", "titles"] },
-    output: "visual-plan",
-    skill: "dxc-visual-plan",
-    stage: "visual-plan"
-  }
-};
-var contentWorkflowWorkItemIdSchema = z3.string().regex(/^wi1_[A-Za-z0-9_-]+\.[a-f0-9]{32}$/u);
-var contentWorkflowChoiceIdSchema = z3.string().regex(/^choice1_[A-Za-z0-9_-]+\.[a-f0-9]{32}$/u);
-var contentWorkflowSectionIdSchema = z3.string().regex(/^sec_[0-9]{2}_[a-f0-9]{8}$/u);
-var contentWorkflowAssetIdSchema = z3.enum([
-  "cover",
-  ...Array.from({ length: 20 }, (_, index) => `inline-${String(index + 1).padStart(2, "0")}`)
-]);
-var contentWorkflowChoiceSchema = z3.object({
-  choiceId: contentWorkflowChoiceIdSchema,
-  label: z3.string().trim().min(1).max(120)
-}).strict();
-var contentWorkflowAssetAssignmentSchema = z3.object({
-  assetId: contentWorkflowAssetIdSchema,
-  path: z3.string().trim().min(1).max(4096),
-  role: z3.enum(["cover", "inline"]),
-  sectionId: contentWorkflowSectionIdSchema.optional()
-}).strict();
-var contentWorkflowNextActionSchema = z3.discriminatedUnion("type", [
-  z3.object({ type: z3.literal("run-stage") }).strict(),
-  z3.object({
-    assets: z3.array(contentWorkflowAssetAssignmentSchema).min(1).max(21),
-    type: z3.literal("generate-assets")
-  }).strict(),
-  z3.object({
-    presentation: z3.object({ path: z3.string().trim().min(1).max(4096), type: z3.literal("artifact") }).strict(),
-    type: z3.literal("confirm-stage")
-  }).strict(),
-  z3.object({
-    choices: z3.array(contentWorkflowChoiceSchema).min(2).max(100),
-    purpose: z3.literal("wechat-account"),
-    type: z3.literal("select-choice")
-  }).strict(),
-  z3.object({ type: z3.literal("preview") }).strict(),
-  z3.object({
-    expiresAt: z3.iso.datetime(),
-    type: z3.literal("confirm-delivery")
-  }).strict(),
-  z3.object({ type: z3.literal("completed") }).strict()
-]);
-var contentWorkflowInputResourceSchema = z3.discriminatedUnion("availability", [
-  z3.object({ availability: z3.literal("missing") }).strict(),
-  z3.object({
-    availability: z3.literal("present"),
-    path: z3.string().trim().min(1).max(4096)
-  }).strict()
-]);
-var contentWorkflowResourcesSchema = z3.object({
-  inputs: z3.record(z3.string(), contentWorkflowInputResourceSchema),
-  output: z3.object({
-    path: z3.string().trim().min(1).max(4096),
-    scaffold: z3.enum(["created", "existing", "not-applicable"])
-  }).strict()
-}).strict();
-var contentWorkflowConstraintsSchema = z3.object({
-  authorMaxCharacters: z3.number().int().positive().optional(),
-  coverMaxBytes: z3.number().int().positive().optional(),
-  digestMaxCharacters: z3.number().int().positive().optional(),
-  inlineImageMaxBytes: z3.number().int().positive().optional(),
-  inlineImageMaxCount: z3.number().int().positive().optional(),
-  supportedImageTypes: z3.array(z3.enum(["image/jpeg", "image/png"])).optional(),
-  titleMaxCharacters: z3.number().int().positive().optional()
-}).strict();
-var contentWorkflowSectionSchema = z3.object({
-  heading: z3.string().trim().min(1).max(300),
-  sectionId: contentWorkflowSectionIdSchema
-}).strict();
-var contentWorkflowProjectSummarySchema = z3.object({
-  projectId: z3.uuid(),
-  title: z3.string().trim().min(1).max(160)
-}).strict();
-var contentWorkflowWorkItemSchema = z3.object({
-  constraints: contentWorkflowConstraintsSchema.optional(),
-  nextAction: contentWorkflowNextActionSchema,
-  resources: contentWorkflowResourcesSchema.optional(),
-  sections: z3.array(contentWorkflowSectionSchema).max(100).optional(),
-  skill: dxcStageSkillNameSchema,
-  stage: contentArtifactKindSchema,
-  workItemId: contentWorkflowWorkItemIdSchema
-}).strict();
-var contentWorkflowNextResultSchema = z3.object({
-  command: z3.literal("workflow.next"),
-  data: z3.object({
-    project: contentWorkflowProjectSummarySchema,
-    workItem: contentWorkflowWorkItemSchema
-  }).strict(),
-  ok: z3.literal(true)
-}).strict();
-function isPortableRelativePath(value) {
-  if (value.startsWith("/") || value.includes("\\") || /[:*?"<>|\0]/u.test(value)) {
-    return false;
-  }
-  return value.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
-}
-var portableRelativePathSchema = z3.string().trim().min(1).max(240).refine(isPortableRelativePath, "path must stay inside the project directory");
-var contentProjectArtifactPathsSchema = z3.object({
-  article: portableRelativePathSchema,
-  brief: portableRelativePathSchema,
-  delivery: portableRelativePathSchema,
-  outline: portableRelativePathSchema,
-  "quality-review": portableRelativePathSchema,
-  research: portableRelativePathSchema,
-  titles: portableRelativePathSchema,
-  "visual-plan": portableRelativePathSchema
-}).strict();
-var contentProjectManifestSchema = z3.object({
-  artifacts: contentProjectArtifactPathsSchema,
-  assetsDirectory: portableRelativePathSchema,
-  // Persisted 0.1.x projects may contain this field. New projects do not create checkpoints.
-  checkpointsDirectory: portableRelativePathSchema.optional(),
-  createdAt: z3.iso.datetime(),
-  projectId: z3.uuid(),
-  schemaVersion: z3.literal("1"),
-  title: z3.string().trim().min(1).max(160),
-  workflowId: z3.literal(CONTENT_WORKFLOW_ID)
-}).strict();
-var contentProjectIndexEntrySchema = z3.object({
-  directory: z3.string().trim().min(1).max(4096),
-  projectId: z3.uuid(),
-  title: z3.string().trim().min(1).max(160),
-  updatedAt: z3.iso.datetime()
-}).strict();
-var contentProjectIndexSchema = z3.object({
-  projects: z3.array(contentProjectIndexEntrySchema).max(1e3),
-  schemaVersion: z3.literal("1")
-}).strict();
-var contentProfileAnswerSchema = z3.object({
-  note: z3.string().trim().max(500).optional(),
-  questionId: z3.string().regex(/^[a-z][a-z0-9.-]{1,63}$/u),
-  selectedOptionIds: z3.array(z3.string().regex(/^[a-z][a-z0-9.-]{1,63}$/u)).min(1).max(8)
-}).strict();
-var contentConfirmationPolicySchema = z3.enum([
-  "guided",
-  "review-every-stage",
-  "auto-until-delivery"
-]);
-var currentProfileUserSchema = z3.object({
-  confirmationPolicy: contentConfirmationPolicySchema.default("guided"),
-  contentValuePromise: z3.string().trim().min(1).max(500),
-  coreValues: z3.string().trim().min(1).max(500).optional(),
-  creatorRole: z3.string().trim().min(1).max(120),
-  displayName: z3.string().trim().min(1).max(120),
-  historyDirectory: z3.string().trim().min(1).max(4096).optional(),
-  penName: z3.string().trim().min(1).max(120).optional(),
-  pointOfView: z3.string().trim().min(1).max(120).optional(),
-  primaryDomains: z3.array(z3.string().trim().min(1).max(120)).min(1).max(5),
-  primaryPlatform: z3.literal("wechat-official-account"),
-  publishingCadence: z3.string().trim().min(1).max(120).optional(),
-  redLines: z3.string().trim().min(1).max(500).optional(),
-  targetAudience: z3.string().trim().min(1).max(500),
-  titlePreferences: z3.string().trim().min(1).max(500).optional(),
-  visualPreferences: z3.string().trim().min(1).max(500).optional(),
-  writingVoice: z3.string().trim().min(1).max(500).optional()
-}).strict();
-var storedProfileUserSchema = currentProfileUserSchema.extend({
-  visualGenerationAuthorization: z3.object({
-    maxImagesPerRun: z3.number().int().min(1).max(20),
-    mode: z3.literal("auto-within-limit")
-  }).strict().optional()
-});
-var contentProfileInputSchema = z3.object({
-  answers: z3.array(contentProfileAnswerSchema).max(32).default([]),
-  questionnaireVersion: z3.literal(CONTENT_PROFILE_QUESTIONNAIRE_VERSION),
-  user: currentProfileUserSchema
-}).strict();
-var contentProfileSchema = z3.object({
-  answers: z3.array(contentProfileAnswerSchema).max(32),
-  createdAt: z3.iso.datetime(),
-  profileId: z3.uuid(),
-  questionnaireVersion: z3.literal(CONTENT_PROFILE_QUESTIONNAIRE_VERSION),
-  schemaVersion: z3.literal("1"),
-  updatedAt: z3.iso.datetime(),
-  user: storedProfileUserSchema
-}).strict();
-var contentProfileResultDataSchema = z3.object({
-  profile: contentProfileSchema,
-  profilePath: z3.literal("~/.dxc/content-profile.json"),
-  userMemoryPath: z3.literal("~/.dxc/USER.md")
-}).strict();
-var contentProfileStatusResultSchema = z3.object({
-  command: z3.literal("profile.status"),
-  data: z3.discriminatedUnion("configured", [
-    z3.object({
-      configured: z3.literal(false),
-      profilePath: z3.literal("~/.dxc/content-profile.json"),
-      userMemoryPath: z3.literal("~/.dxc/USER.md")
-    }).strict(),
-    contentProfileResultDataSchema.extend({ configured: z3.literal(true) }).strict()
-  ]),
-  ok: z3.literal(true)
-}).strict();
-var contentProfileSessionIdSchema = z3.uuid();
-var contentProfileQuestionSchema = z3.object({
-  choices: z3.array(
-    z3.object({
-      choiceId: z3.string().regex(/^profile_[a-z0-9.-]+$/u),
-      label: z3.string().trim().min(1).max(120)
-    }).strict()
-  ).max(12),
-  inputType: z3.enum(["multi-choice", "single-choice", "text"]),
-  prompt: z3.string().trim().min(1).max(500),
-  questionId: z3.string().regex(/^[a-z][a-z0-9.-]{1,63}$/u)
-}).strict();
-var contentProfileSessionResultSchema = z3.object({
-  command: z3.enum(["profile.answer", "profile.begin"]),
-  data: z3.discriminatedUnion("status", [
-    z3.object({
-      profileSessionId: contentProfileSessionIdSchema,
-      question: contentProfileQuestionSchema,
-      status: z3.literal("question")
-    }).strict(),
-    z3.object({
-      profile: contentProfileSchema,
-      profilePath: z3.literal("~/.dxc/content-profile.json"),
-      status: z3.literal("completed"),
-      userMemoryPath: z3.literal("~/.dxc/USER.md")
-    }).strict()
-  ]),
-  ok: z3.literal(true)
-}).strict();
-var contentProfileCommandSchema = z3.enum([
-  "profile.answer",
-  "profile.begin",
-  "profile.status"
-]);
-var contentProfileErrorResultSchema = z3.object({
-  command: contentProfileCommandSchema,
-  error: z3.object({
-    code: z3.enum(["DXC_PROFILE_INPUT_INVALID", "DXC_PROFILE_INVALID", "DXC_PROFILE_IO_FAILED"]),
-    fields: z3.array(z3.string().trim().min(1)).optional(),
-    hint: z3.string().trim().min(1).optional(),
-    message: z3.string().trim().min(1)
-  }).strict(),
-  ok: z3.literal(false)
-}).strict();
-var CONTENT_MEMORY_KINDS = [
-  "audience-change",
-  "brand-context",
-  "business-context",
-  "temporary-campaign",
-  "writing-preference"
-];
-var contentMemoryKindSchema = z3.enum(CONTENT_MEMORY_KINDS);
-var contentMemoryScopeSchema = z3.enum(["global", "project"]);
-var contentMemoryInputSchema = z3.object({
-  content: z3.string().trim().min(1).max(500),
-  expiresAt: z3.iso.datetime().optional(),
-  kind: contentMemoryKindSchema,
-  scope: contentMemoryScopeSchema
-}).strict().refine((input) => input.kind !== "temporary-campaign" || input.expiresAt !== void 0, {
-  message: "temporary campaign memory requires an expiry time"
-});
-var contentMemoryRecordSchema = contentMemoryInputSchema.and(
-  z3.object({
-    createdAt: z3.iso.datetime(),
-    id: z3.uuid(),
-    source: z3.literal("user-stated"),
-    status: z3.enum(["active", "archived", "expired"]),
-    updatedAt: z3.iso.datetime()
-  }).strict()
-);
-var contentMemoryStoreSchema = z3.object({ memories: z3.array(contentMemoryRecordSchema).max(100), schemaVersion: z3.literal("1") }).strict();
-var contentMemoryResultDataSchema = z3.object({
-  memories: z3.array(contentMemoryRecordSchema),
-  memoryPath: z3.literal("~/.dxc/content-memory.json")
-}).strict();
-var contentMemoryAddResultSchema = z3.object({
-  command: z3.literal("memory.add"),
-  data: contentMemoryResultDataSchema.extend({ memory: contentMemoryRecordSchema }),
-  ok: z3.literal(true)
-}).strict();
-var contentMemoryArchiveResultSchema = z3.object({
-  command: z3.literal("memory.archive"),
-  data: contentMemoryResultDataSchema.extend({ memory: contentMemoryRecordSchema }),
-  ok: z3.literal(true)
-}).strict();
-var contentMemoryCorrectResultSchema = z3.object({
-  command: z3.literal("memory.correct"),
-  data: contentMemoryResultDataSchema.extend({
-    archivedMemory: contentMemoryRecordSchema,
-    memory: contentMemoryRecordSchema
-  }),
-  ok: z3.literal(true)
-}).strict();
-var contentMemoryListResultSchema = z3.object({
-  command: z3.literal("memory.list"),
-  data: contentMemoryResultDataSchema,
-  ok: z3.literal(true)
-}).strict();
-var contentMemoryCommandSchema = z3.enum([
-  "memory.add",
-  "memory.archive",
-  "memory.correct",
-  "memory.list"
-]);
-var contentMemoryErrorResultSchema = z3.object({
-  command: contentMemoryCommandSchema,
-  error: z3.object({
-    code: z3.enum([
-      "DXC_MEMORY_INPUT_INVALID",
-      "DXC_MEMORY_INVALID",
-      "DXC_MEMORY_IO_FAILED",
-      "DXC_MEMORY_NOT_FOUND"
-    ]),
-    message: z3.string().trim().min(1)
-  }).strict(),
-  ok: z3.literal(false)
-}).strict();
-
-// packages/contracts/src/content-monitor.ts
-import { z as z5 } from "zod";
-
-// packages/contracts/src/content-source.ts
-import { z as z4 } from "zod";
-var sourceFetchKindSchema = z4.enum(["rss", "api", "html"]);
-var sourceExecutionLocationSchema = z4.literal("local-device");
-var sourceDataTransitSchema = z4.literal("local-only");
-var sourceCaptureMetadataSchema = z4.object({
-  capturedAt: z4.iso.datetime(),
-  contentHash: z4.string().regex(/^[a-f0-9]{64}$/u),
-  dataTransit: sourceDataTransitSchema,
-  executionLocation: sourceExecutionLocationSchema,
-  extractor: z4.string().trim().min(1).max(120),
-  finalUrl: z4.url(),
-  mediaType: z4.string().trim().min(1).max(160),
-  sourceUrl: z4.url()
-}).strict();
-var sourceFeedItemSchema = z4.object({
-  id: z4.string().trim().min(1).max(256),
-  publishedAt: z4.iso.datetime().optional(),
-  summary: z4.string().trim().min(1).max(2e3).optional(),
-  title: z4.string().trim().min(1).max(500),
-  url: z4.url().optional()
-}).strict();
-var sourceHtmlDocumentSchema = z4.object({
-  canonicalUrl: z4.url().optional(),
-  excerpt: z4.string().trim().min(1).max(12e3),
-  title: z4.string().trim().min(1).max(500)
-}).strict();
-var sourceFetchDataSchema = z4.discriminatedUnion("kind", [
-  z4.object({
-    capture: sourceCaptureMetadataSchema,
-    items: z4.array(sourceFeedItemSchema).max(100),
-    kind: z4.literal("rss")
-  }).strict(),
-  z4.object({
-    capture: sourceCaptureMetadataSchema,
-    kind: z4.literal("api"),
-    payload: z4.unknown()
-  }).strict(),
-  z4.object({
-    capture: sourceCaptureMetadataSchema,
-    document: sourceHtmlDocumentSchema,
-    kind: z4.literal("html")
-  }).strict()
-]);
-var sourceFetchResultSchema = z4.object({
-  command: z4.literal("source.fetch"),
-  data: sourceFetchDataSchema,
-  ok: z4.literal(true)
-}).strict();
-var sourceFetchErrorResultSchema = z4.object({
-  command: z4.literal("source.fetch"),
-  error: z4.object({
-    code: z4.enum([
-      "DXC_SOURCE_AUTH_MISSING",
-      "DXC_SOURCE_CONTENT_INVALID",
-      "DXC_SOURCE_FETCH_FAILED",
-      "DXC_SOURCE_REDIRECT_LIMIT",
-      "DXC_SOURCE_RESPONSE_TOO_LARGE",
-      "DXC_SOURCE_URL_BLOCKED",
-      "DXC_SOURCE_URL_INVALID"
-    ]).or(z4.literal("DXC_SOURCE_FAILED")),
-    message: z4.string().trim().min(1).max(500),
-    recovery: z4.string().trim().min(1).max(800).optional()
-  }).strict(),
-  ok: z4.literal(false)
-}).strict();
-
-// packages/contracts/src/content-monitor.ts
-var contentMonitorSourceSchema = z5.object({
-  bearerEnvironment: z5.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/u).nullable(),
-  createdAt: z5.iso.datetime(),
-  enabled: z5.boolean(),
-  headerEnvironments: z5.array(
-    z5.object({
-      environment: z5.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/u),
-      header: z5.string().regex(/^[A-Za-z0-9-]+$/u)
-    }).strict()
-  ).max(12),
-  id: z5.uuid(),
-  kind: sourceFetchKindSchema,
-  name: z5.string().trim().min(1).max(120),
-  rssLimit: z5.number().int().min(1).max(100).nullable(),
-  url: z5.url()
-}).strict();
-var contentMonitorSourceSummarySchema = contentMonitorSourceSchema.extend({
-  lastRunAt: z5.iso.datetime().nullable(),
-  lastRunSummary: z5.string().trim().min(1).max(200).nullable(),
-  latestItemAt: z5.iso.datetime().nullable(),
-  observedItemCount: z5.number().int().nonnegative()
-});
-var contentMonitorRunSourceResultSchema = z5.object({
-  failureMessage: z5.string().trim().min(1).max(500).nullable(),
-  monitoredItemCount: z5.number().int().nonnegative(),
-  newItemCount: z5.number().int().nonnegative(),
-  sourceId: z5.uuid(),
-  sourceName: z5.string().trim().min(1).max(120),
-  summary: z5.string().trim().min(1).max(200),
-  unchangedItemCount: z5.number().int().nonnegative(),
-  updatedItemCount: z5.number().int().nonnegative()
-}).strict();
-var contentMonitorAddResultSchema = z5.object({
-  command: z5.literal("monitor.add"),
-  data: z5.object({
-    source: contentMonitorSourceSchema,
-    summary: z5.string().trim().min(1).max(200)
-  }).strict(),
-  ok: z5.literal(true)
-}).strict();
-var contentMonitorListResultSchema = z5.object({
-  command: z5.literal("monitor.list"),
-  data: z5.object({
-    sources: z5.array(contentMonitorSourceSummarySchema),
-    summary: z5.string().trim().min(1).max(200)
-  }).strict(),
-  ok: z5.literal(true)
-}).strict();
-var contentMonitorRunResultSchema = z5.object({
-  command: z5.literal("monitor.run"),
-  data: z5.object({
-    failedSourceCount: z5.number().int().nonnegative(),
-    finishedAt: z5.iso.datetime(),
-    results: z5.array(contentMonitorRunSourceResultSchema),
-    startedAt: z5.iso.datetime(),
-    summary: z5.string().trim().min(1).max(200)
-  }).strict(),
-  ok: z5.literal(true)
-}).strict();
-var contentMonitorStatusResultSchema = z5.object({
-  command: z5.literal("monitor.status"),
-  data: z5.object({
-    databasePath: z5.literal("~/.dxc/source-monitor.sqlite"),
-    enabledSourceCount: z5.number().int().nonnegative(),
-    latestRunAt: z5.iso.datetime().nullable(),
-    latestRunSummary: z5.string().trim().min(1).max(200).nullable(),
-    sourceCount: z5.number().int().nonnegative(),
-    summary: z5.string().trim().min(1).max(200)
-  }).strict(),
-  ok: z5.literal(true)
-}).strict();
-var contentMonitorRemoveResultSchema = z5.object({
-  command: z5.literal("monitor.remove"),
-  data: z5.object({
-    removed: z5.boolean(),
-    sourceId: z5.uuid(),
-    summary: z5.string().trim().min(1).max(200)
-  }).strict(),
-  ok: z5.literal(true)
-}).strict();
-var contentMonitorCommandSchema = z5.enum([
-  "monitor.add",
-  "monitor.list",
-  "monitor.remove",
-  "monitor.run",
-  "monitor.status"
-]);
-var contentMonitorErrorResultSchema = z5.object({
-  command: contentMonitorCommandSchema,
-  error: z5.object({
-    code: z5.enum([
-      "DXC_MONITOR_IO_FAILED",
-      "DXC_MONITOR_SCHEMA_UNSUPPORTED",
-      "DXC_MONITOR_SOURCE_INVALID",
-      "DXC_MONITOR_SOURCE_NOT_FOUND",
-      "DXC_MONITOR_STATE_INVALID"
-    ]),
-    message: z5.string().trim().min(1).max(500)
-  }).strict(),
-  ok: z5.literal(false)
-}).strict();
-
-// packages/contracts/src/index.ts
-var liveHealthResponseSchema = z6.object({
-  status: z6.literal("ok")
-}).strict();
-var readyHealthResponseSchema = z6.object({
-  status: z6.literal("ready"),
-  checks: z6.object({
-    configuration: z6.literal("ok")
-  }).strict()
-}).strict();
-var versionResultSchema = z6.object({
-  ok: z6.literal(true),
-  command: z6.literal("version"),
-  data: z6.object({
-    cliVersion: z6.string().min(1),
-    nodeVersion: z6.string().min(1)
-  }).strict()
-}).strict();
-var doctorCheckSchema = z6.object({
-  name: z6.enum(["node-runtime", "working-directory"]),
-  status: z6.enum(["ok", "error"]),
-  message: z6.string().min(1)
-}).strict();
-var doctorResultSchema = z6.object({
-  ok: z6.boolean(),
-  command: z6.literal("doctor"),
-  data: z6.object({
-    status: z6.enum(["ok", "error"]),
-    checks: z6.array(doctorCheckSchema)
-  }).strict()
-}).strict();
-var articleAssetSchema = z6.object({
-  logicalPath: z6.string().trim().min(1),
-  role: z6.enum(["cover", "inline"])
-}).strict();
-var articleBundleSchema = z6.object({
-  schemaVersion: z6.literal("1"),
-  title: z6.string().trim().min(1),
-  author: z6.string().trim().min(1),
-  digest: z6.string().trim().min(1),
-  templateHint: wechatTemplateIdSchema.optional(),
-  coverImage: z6.string().trim().min(1).optional(),
-  commentsEnabled: z6.boolean(),
-  tags: z6.array(z6.string().trim().min(1)),
-  markdown: z6.string().trim().min(1),
-  assets: z6.array(articleAssetSchema)
-}).strict();
-var preflightIssueSchema = z6.object({
-  code: z6.string().trim().min(1),
-  path: z6.string().trim().min(1).optional(),
-  message: z6.string().trim().min(1)
-}).strict();
-var preflightResultSchema = z6.object({
-  ok: z6.boolean(),
-  errors: z6.array(preflightIssueSchema),
-  warnings: z6.array(preflightIssueSchema),
-  metrics: z6.object({
-    digestCharacters: z6.number().int().nonnegative(),
-    htmlCharacters: z6.number().int().nonnegative(),
-    imageCount: z6.number().int().nonnegative(),
-    externalLinkCount: z6.number().int().nonnegative(),
-    tableCount: z6.number().int().nonnegative()
-  }).strict()
-}).strict();
-var wechatRenderResultSchema = z6.object({
-  templateId: wechatTemplateIdSchema,
-  rendererVersion: z6.string().trim().min(1),
-  sourceHash: z6.string().regex(/^[a-f0-9]{64}$/u),
-  htmlHash: z6.string().regex(/^[a-f0-9]{64}$/u),
-  html: z6.string().min(1),
-  preflight: preflightResultSchema
-}).strict();
-var wechatPermissionIdSchema = z6.union([z6.literal(3), z6.literal(11)]);
-var deviceBindingSessionStatusSchema = z6.enum([
-  "CREATED",
-  "PROVED",
-  "AUTHORIZATION_PENDING",
-  "BOUND",
-  "EXPIRED",
-  "FAILED"
-]);
-var createDeviceBindingSessionRequestSchema = z6.object({
-  deviceName: z6.string().trim().min(1).max(80),
-  installationId: z6.uuid(),
-  publicKeyPem: z6.string().min(80).max(2048)
-}).strict();
-var createDeviceBindingSessionResponseSchema = z6.object({
-  challenge: z6.string().regex(/^[A-Za-z0-9_-]{43,128}$/u),
-  expiresAt: z6.iso.datetime(),
-  id: z6.uuid()
-}).strict();
-var proveDeviceBindingSessionRequestSchema = z6.object({
-  challenge: z6.string().regex(/^[A-Za-z0-9_-]{43,128}$/u),
-  deviceRefreshTokenHash: z6.string().regex(/^[a-f0-9]{64}$/u).optional(),
-  deviceSessionTokenHash: z6.string().regex(/^[a-f0-9]{64}$/u),
-  signature: z6.string().regex(/^[A-Za-z0-9_-]{64,256}$/u)
-}).strict();
-var proveDeviceBindingSessionResponseSchema = z6.object({
-  bindingToken: z6.string().min(32).max(256),
-  expiresAt: z6.iso.datetime(),
-  id: z6.uuid(),
-  status: z6.literal("PROVED")
-}).strict();
-var deviceSessionIdentitySchema = z6.object({
-  deviceId: z6.uuid(),
-  deviceName: z6.string().trim().min(1).max(80),
-  expiresAt: z6.iso.datetime(),
-  tenantId: z6.uuid(),
-  userId: z6.uuid()
-}).strict();
-var deviceSessionStatusResponseSchema = z6.object({
-  identity: deviceSessionIdentitySchema
-}).strict();
-var deviceSessionCredentialEnrollmentRequestSchema = z6.object({
-  refreshTokenHash: z6.string().regex(/^[a-f0-9]{64}$/u),
-  signature: z6.string().regex(/^[A-Za-z0-9_-]{64,256}$/u)
-}).strict();
-var deviceSessionRefreshRequestSchema = z6.object({
-  nextDeviceSessionTokenHash: z6.string().regex(/^[a-f0-9]{64}$/u),
-  nextRefreshTokenHash: z6.string().regex(/^[a-f0-9]{64}$/u),
-  refreshToken: z6.string().regex(/^[A-Za-z0-9_-]{43,256}$/u),
-  rotationId: z6.uuid(),
-  signature: z6.string().regex(/^[A-Za-z0-9_-]{64,256}$/u)
-}).strict();
-var wechatLoginSessionPurposeSchema = z6.enum(["link", "login", "start"]);
-var wechatLoginSessionStatusSchema = z6.enum([
-  "URL_READY",
-  "EXCHANGING",
-  "IDENTIFIED",
-  "SUCCEEDED",
-  "EXPIRED",
-  "FAILED"
-]);
-var wechatLoginFailureCodeSchema = z6.enum([
-  "WECHAT_LOGIN_DEVICE_UNAUTHORIZED",
-  "WECHAT_LOGIN_IDENTITY_CONFLICT",
-  "WECHAT_LOGIN_IDENTITY_NOT_LINKED",
-  "WECHAT_LOGIN_PROVIDER_FAILED",
-  "WECHAT_LOGIN_SESSION_INVALID"
-]);
-var createWechatLoginSessionRequestSchema = z6.object({
-  purpose: wechatLoginSessionPurposeSchema
-}).strict();
-var createWechatLoginSessionResponseSchema = z6.object({
-  authorizationUrl: z6.url(),
-  expiresAt: z6.iso.datetime(),
-  id: z6.uuid(),
-  pollToken: z6.string().min(32).max(256),
-  purpose: wechatLoginSessionPurposeSchema
-}).strict();
-var wechatLoginSessionResponseSchema = z6.object({
-  expiresAt: z6.iso.datetime(),
-  failureCode: wechatLoginFailureCodeSchema.optional(),
-  id: z6.uuid(),
-  identity: deviceSessionIdentitySchema.optional(),
-  purpose: wechatLoginSessionPurposeSchema,
-  status: wechatLoginSessionStatusSchema
-}).strict().superRefine((session, context) => {
-  if (session.status === "SUCCEEDED" && session.identity === void 0) {
-    context.addIssue({
-      code: "custom",
-      message: "successful login session requires an identity"
-    });
-  }
-  if (session.status === "FAILED" && session.failureCode === void 0) {
-    context.addIssue({
-      code: "custom",
-      message: "failed login session requires a failure code"
-    });
-  }
-  if (session.status !== "FAILED" && session.failureCode !== void 0) {
-    context.addIssue({
-      code: "custom",
-      message: "only failed login session may expose a failure code"
-    });
-  }
-});
-var wechatAccountSchema = z6.object({
-  id: z6.uuid(),
-  displayName: z6.string().trim().min(1),
-  accountType: z6.string().trim().min(1),
-  status: z6.enum(["ACTIVE", "PERMISSION_CHANGED", "REVOKED"]),
-  permissions: z6.array(wechatPermissionIdSchema),
-  draftCapability: z6.enum(["available", "missing", "revoked"])
-}).strict();
-var createWechatAuthorizationSessionResponseSchema = z6.object({
-  id: z6.uuid(),
-  authorizationUrl: z6.url(),
-  pollToken: z6.string().min(32).max(256),
-  expiresAt: z6.iso.datetime()
-}).strict();
-var wechatAuthorizationSessionResponseSchema = z6.object({
-  id: z6.uuid(),
-  status: z6.enum(["URL_READY", "EXCHANGING", "AUTHORIZED", "BOUND", "EXPIRED", "FAILED"]),
-  expiresAt: z6.iso.datetime(),
-  account: wechatAccountSchema.optional()
-}).strict();
-var wechatAccountsResponseSchema = z6.object({
-  accounts: z6.array(wechatAccountSchema)
-}).strict();
-var apiErrorResponseSchema = z6.object({
-  error: z6.object({
-    code: z6.string().trim().min(1),
-    message: z6.string().trim().min(1),
-    retryable: z6.boolean()
-  }).strict()
-}).strict();
-
-// apps/cli/src/local-state.ts
-import { randomUUID } from "node:crypto";
-import { constants as fileConstants } from "node:fs";
-import { chmod, lstat, mkdir, open, rename, unlink } from "node:fs/promises";
-import path from "node:path";
-var LocalStateError = class extends Error {
-  constructor(failure) {
-    super(failure);
-    this.failure = failure;
-    this.name = "LocalStateError";
-  }
-  failure;
-};
-function errorCode(error) {
-  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
-}
-function ownedByCurrentUser(userId, ownerId) {
-  return userId === void 0 || userId === ownerId;
-}
-async function ensurePrivateDirectory(directory) {
-  try {
-    await mkdir(directory, { mode: 448, recursive: true });
-    const metadata = await lstat(directory);
-    const userId = typeof process.getuid === "function" ? process.getuid() : void 0;
-    if (!metadata.isDirectory() || metadata.isSymbolicLink() || !ownedByCurrentUser(userId, metadata.uid)) {
-      throw new LocalStateError("invalid");
-    }
-    await chmod(directory, 448);
-  } catch (error) {
-    if (error instanceof LocalStateError) {
-      throw error;
-    }
-    if (errorCode(error) === "ELOOP") {
-      throw new LocalStateError("invalid");
-    }
-    throw new LocalStateError("io");
-  }
-}
-async function ensurePrivateRegularFile(target) {
-  await ensurePrivateDirectory(path.dirname(target));
-  let handle;
-  try {
-    handle = await open(
-      target,
-      fileConstants.O_CREAT | fileConstants.O_RDWR | fileConstants.O_NOFOLLOW,
-      384
-    );
-    const metadata = await handle.stat();
-    const userId = typeof process.getuid === "function" ? process.getuid() : void 0;
-    if (!metadata.isFile() || !ownedByCurrentUser(userId, metadata.uid)) {
-      throw new LocalStateError("invalid");
-    }
-    await handle.chmod(384);
-  } catch (error) {
-    if (error instanceof LocalStateError) {
-      throw error;
-    }
-    if (errorCode(error) === "ELOOP") {
-      throw new LocalStateError("invalid");
-    }
-    throw new LocalStateError("io");
-  } finally {
-    await handle?.close();
-  }
-}
-async function readPrivateFile(target, maximumBytes) {
-  const contents = await readPrivateBuffer(target, maximumBytes);
-  return contents.toString("utf8");
-}
-async function readPrivateBuffer(target, maximumBytes) {
-  let handle;
-  try {
-    handle = await open(target, fileConstants.O_RDONLY | fileConstants.O_NOFOLLOW);
-  } catch (error) {
-    if (errorCode(error) === "ENOENT") {
-      throw new LocalStateError("missing");
-    }
-    if (errorCode(error) === "ELOOP") {
-      throw new LocalStateError("invalid");
-    }
-    throw new LocalStateError("io");
-  }
-  try {
-    const metadata = await handle.stat();
-    const userId = typeof process.getuid === "function" ? process.getuid() : void 0;
-    if (!metadata.isFile() || !ownedByCurrentUser(userId, metadata.uid) || metadata.size > maximumBytes || process.platform !== "win32" && (metadata.mode & 63) !== 0) {
-      throw new LocalStateError("invalid");
-    }
-    return await handle.readFile();
-  } catch (error) {
-    if (error instanceof LocalStateError) {
-      throw error;
-    }
-    throw new LocalStateError("io");
-  } finally {
-    await handle.close();
-  }
-}
-async function writePrivateJson(target, value) {
-  await writePrivateBuffer(target, Buffer.from(`${JSON.stringify(value, void 0, 2)}
-`, "utf8"));
-}
-async function writePrivateBuffer(target, value) {
-  const directory = path.dirname(target);
-  await ensurePrivateDirectory(directory);
-  const temporary = path.join(directory, `.${path.basename(target)}.${randomUUID()}.tmp`);
-  let handle;
-  try {
-    handle = await open(
-      temporary,
-      fileConstants.O_CREAT | fileConstants.O_EXCL | fileConstants.O_WRONLY | fileConstants.O_NOFOLLOW,
-      384
-    );
-    await handle.writeFile(value);
-    await handle.sync();
-    await handle.close();
-    handle = void 0;
-    await rename(temporary, target);
-    await chmod(target, 384);
-  } catch (error) {
-    throw error instanceof LocalStateError ? error : new LocalStateError("io");
-  } finally {
-    await handle?.close();
-    await unlink(temporary).catch(() => void 0);
-  }
-}
-
-// apps/cli/src/user-path.ts
-import path2 from "node:path";
-function expandHome(input, homeDirectory, pathApi) {
-  if (input === "~") {
-    return homeDirectory;
-  }
-  if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return pathApi.join(homeDirectory, input.slice(2));
-  }
-  return input;
-}
-function windowsShellPath(input) {
-  const msys = /^\/([a-z])(?:\/(.*))?$/iu.exec(input);
-  if (msys !== null) {
-    return `${msys[1]?.toUpperCase()}:\\${(msys[2] ?? "").replaceAll("/", "\\")}`;
-  }
-  const mounted = /^\/(?:cygdrive|mnt)\/([a-z])(?:\/(.*))?$/iu.exec(input);
-  if (mounted !== null) {
-    return `${mounted[1]?.toUpperCase()}:\\${(mounted[2] ?? "").replaceAll("/", "\\")}`;
-  }
-  return input;
-}
-function resolveUserPath(options) {
-  const platform = options.platform ?? process.platform;
-  const pathApi = platform === "win32" ? path2.win32 : path2.posix;
-  const expanded = expandHome(options.input, options.homeDirectory, pathApi);
-  if (platform === "win32") {
-    return pathApi.resolve(options.currentDirectory, windowsShellPath(expanded));
-  }
-  return pathApi.resolve(options.currentDirectory, expanded);
-}
-
-export {
-  __require,
-  __esm,
-  __commonJS,
-  __export,
-  __toESM,
-  __toCommonJS,
-  publishingUploadSessionSchema,
-  publishingUploadReceiptSchema,
-  publishingArticleSchema,
-  publishingRenderSnapshotSchema,
-  publishingPreviewLinkSchema,
-  publishingPreviewSelectionStateSchema,
-  createPublishingApprovalRequestSchema,
-  publishingApprovalSchema,
-  publishingDraftIntentResponseSchema,
-  publishingDraftAttentionDiagnosticsSchema,
-  CONTENT_WORKFLOW_ID,
-  CONTENT_ARTIFACT_KINDS,
-  CONTENT_STAGE_DEFINITIONS,
-  portableRelativePathSchema,
-  contentProjectManifestSchema,
-  contentProjectIndexSchema,
-  contentProfileInputSchema,
-  contentProfileSchema,
-  contentProfileStatusResultSchema,
-  contentProfileSessionResultSchema,
-  contentMemoryInputSchema,
-  contentMemoryStoreSchema,
-  contentMemoryAddResultSchema,
-  contentMemoryArchiveResultSchema,
-  contentMemoryCorrectResultSchema,
-  contentMemoryListResultSchema,
-  CONTENT_KNOWLEDGE_SCHEMA_VERSION,
-  CONTENT_KNOWLEDGE_EMBEDDING_MODEL,
-  CONTENT_KNOWLEDGE_EMBEDDING_REVISION,
-  CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS,
-  CONTENT_KNOWLEDGE_EMBEDDING_QUANTIZATION,
-  CONTENT_KNOWLEDGE_CHUNKER_VERSION,
-  contentKnowledgeSearchModeSchema,
-  contentKnowledgeModelSchema,
-  contentKnowledgeImportResultSchema,
-  contentKnowledgeQuoteListResultSchema,
-  contentKnowledgeQuoteMutationResultSchema,
-  contentKnowledgeQuoteStatusResultSchema,
-  contentKnowledgeSearchResultSchema,
-  contentKnowledgeStatusResultSchema,
-  contentKnowledgeRemoveResultSchema,
-  doctorResultSchema,
-  articleBundleSchema,
-  preflightResultSchema,
-  wechatRenderResultSchema,
-  createDeviceBindingSessionResponseSchema,
-  proveDeviceBindingSessionResponseSchema,
-  deviceSessionStatusResponseSchema,
-  createWechatLoginSessionResponseSchema,
-  wechatLoginSessionResponseSchema,
-  createWechatAuthorizationSessionResponseSchema,
-  wechatAuthorizationSessionResponseSchema,
-  wechatAccountsResponseSchema,
-  apiErrorResponseSchema,
-  LocalStateError,
-  ensurePrivateDirectory,
-  ensurePrivateRegularFile,
-  readPrivateFile,
-  readPrivateBuffer,
-  writePrivateJson,
-  writePrivateBuffer,
-  resolveUserPath
-};