@deployxai/dxc 0.1.13 → 0.2.1

package/dist/chunks/chunk-7DMYDQPR.js

@@ -0,0 +1,1324 @@
+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({ pendingSync: z.literal(true), quote: contentKnowledgeQuoteRecordSchema }).strict(),
+  ok: z.literal(true)
+}).strict();
+var contentKnowledgeQuoteInitResultSchema = z.object({
+  command: z.literal("knowledge.quotes.init"),
+  data: contentKnowledgeQuoteSummarySchema.extend({ created: z.boolean() }).strict(),
+  ok: z.literal(true)
+}).strict();
+var contentKnowledgeQuoteStatusResultSchema = z.object({
+  command: z.literal("knowledge.quotes.status"),
+  data: contentKnowledgeQuoteSummarySchema,
+  ok: z.literal(true)
+}).strict();
+var contentKnowledgeQuoteSyncResultSchema = z.object({
+  command: z.literal("knowledge.quotes.sync"),
+  data: contentKnowledgeQuoteSummarySchema.extend({
+    model: contentKnowledgeModelSchema.nullable(),
+    status: z.enum(["created", "updated", "unchanged"])
+  }).strict(),
+  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.init",
+  "knowledge.quotes.add",
+  "knowledge.quotes.archive",
+  "knowledge.quotes.list",
+  "knowledge.quotes.status",
+  "knowledge.quotes.sync",
+  "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"
+    ]),
+    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();
+
+// 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 CONTENT_STAGE_INPUTS = {
+  article: { optional: [], required: ["research", "brief", "outline"] },
+  brief: { optional: [], required: ["research"] },
+  delivery: { optional: [], required: ["article", "titles", "visual-plan", "quality-review"] },
+  outline: { optional: [], required: ["research", "brief"] },
+  "quality-review": { optional: ["visual-plan"], required: ["research", "article", "titles"] },
+  research: { optional: [], required: [] },
+  titles: { optional: ["brief"], required: ["article"] },
+  "visual-plan": { optional: ["outline"], required: ["article", "titles"] }
+};
+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 currentProfileUserSchema = z3.object({
+  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({
+  confirmationPolicy: z3.enum(["guided", "review-every-stage", "auto-until-delivery"]).optional(),
+  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 { primaryPlatform: ignoredPrimaryPlatform, ...profileUpdateUserShape } = currentProfileUserSchema.shape;
+var contentProfileUpdateInputSchema = z3.object({
+  answers: z3.array(contentProfileAnswerSchema).min(1).max(32).optional(),
+  user: z3.object(profileUpdateUserShape).partial().optional()
+}).strict().refine((input) => input.answers !== void 0 || input.user !== void 0, {
+  message: "profile update must include answers or user fields"
+});
+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 contentProfileSaveResultSchema = z3.object({
+  command: z3.literal("profile.save"),
+  data: contentProfileResultDataSchema,
+  ok: z3.literal(true)
+}).strict();
+var contentProfileUpdateResultSchema = z3.object({
+  command: z3.literal("profile.update"),
+  data: contentProfileResultDataSchema,
+  ok: z3.literal(true)
+}).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 contentProfileCommandSchema = z3.enum([
+  "profile.save",
+  "profile.status",
+  "profile.update"
+]);
+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 contentMemoryListResultSchema = z3.object({
+  command: z3.literal("memory.list"),
+  data: contentMemoryResultDataSchema,
+  ok: z3.literal(true)
+}).strict();
+var contentMemoryCommandSchema = z3.enum(["memory.add", "memory.archive", "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,
+  CONTENT_WORKFLOW_ID,
+  CONTENT_ARTIFACT_KINDS,
+  CONTENT_STAGE_INPUTS,
+  portableRelativePathSchema,
+  contentProjectManifestSchema,
+  contentProjectIndexSchema,
+  contentProfileInputSchema,
+  contentProfileUpdateInputSchema,
+  contentProfileSchema,
+  contentProfileSaveResultSchema,
+  contentProfileUpdateResultSchema,
+  contentProfileStatusResultSchema,
+  contentMemoryInputSchema,
+  contentMemoryStoreSchema,
+  contentMemoryAddResultSchema,
+  contentMemoryArchiveResultSchema,
+  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,
+  contentKnowledgeQuoteInitResultSchema,
+  contentKnowledgeQuoteStatusResultSchema,
+  contentKnowledgeQuoteSyncResultSchema,
+  contentKnowledgeSearchResultSchema,
+  contentKnowledgeStatusResultSchema,
+  contentKnowledgeRemoveResultSchema,
+  doctorResultSchema,
+  articleBundleSchema,
+  preflightResultSchema,
+  wechatRenderResultSchema,
+  createDeviceBindingSessionResponseSchema,
+  proveDeviceBindingSessionResponseSchema,
+  deviceSessionStatusResponseSchema,
+  createWechatLoginSessionResponseSchema,
+  wechatLoginSessionResponseSchema,
+  createWechatAuthorizationSessionResponseSchema,
+  wechatAuthorizationSessionResponseSchema,
+  wechatAccountsResponseSchema,
+  apiErrorResponseSchema,
+  LocalStateError,
+  ensurePrivateDirectory,
+  ensurePrivateRegularFile,
+  readPrivateFile,
+  readPrivateBuffer,
+  writePrivateJson,
+  writePrivateBuffer,
+  resolveUserPath
+};