jacky-creator 0.1.0-beta.6

package/lib/typert.host.js

@@ -0,0 +1,1006 @@
+import { z } from "zod";
+const PUBLISH_PLATFORMS = Object.freeze(Object.keys({
+	xiaohongshu: {
+		name: "小红书",
+		icon: "xhs",
+		settingsLabel: "settings.platform.xiaohongshu",
+		inspectorLabel: "inspector.platform.xhs",
+		collectUrl: "https://creator.xiaohongshu.com/new/note-manager"
+	},
+	douyin: {
+		name: "抖音",
+		icon: "douyin",
+		settingsLabel: "settings.platform.douyin",
+		inspectorLabel: "inspector.platform.douyin",
+		collectUrl: "https://creator.douyin.com/creator-micro/content/manage"
+	},
+	bilibili: {
+		name: "B站",
+		icon: "bilibili",
+		settingsLabel: "settings.platform.bilibili",
+		inspectorLabel: "inspector.platform.bilibili",
+		collectUrl: "https://member.bilibili.com/platform/upload-manager/article"
+	},
+	wechat: {
+		name: "视频号",
+		icon: "wechat",
+		settingsLabel: "settings.platform.wechat",
+		inspectorLabel: "inspector.platform.wechat",
+		collectUrl: "https://channels.weixin.qq.com/platform/post/list"
+	}
+}));
+//#endregion
+//#region src/schemas.ts
+const contentCoversSchema = z.object({
+	"3x4": z.string().optional(),
+	"4x3": z.string().optional(),
+	"16x9": z.string().optional()
+});
+const contentSubtitlesSchema = z.object({
+	srt: z.string().optional(),
+	ass: z.string().optional(),
+	transcript: z.string().optional()
+});
+const contentPresentationsSchema = z.object({
+	"16x9": z.string().optional(),
+	"3x4": z.string().optional()
+});
+const pipelineSchema = z.union([
+	z.literal("raw"),
+	z.literal("subtitled"),
+	z.literal("covered"),
+	z.literal("packaged")
+]);
+const workflowSchema = z.union([
+	z.literal("idle"),
+	z.literal("record"),
+	z.literal("cut"),
+	z.literal("finish"),
+	z.literal("publish"),
+	z.literal("live")
+]);
+const contentOptionalStepSchema = z.union([
+	z.literal("presentation"),
+	z.literal("subtitle"),
+	z.literal("article")
+]);
+const publishMarkSchema = z.union([
+	z.literal("unpublished"),
+	z.literal("draft"),
+	z.literal("published")
+]);
+const publishPlatformSchema = z.enum(PUBLISH_PLATFORMS);
+const platformPublishSchema = z.object({
+	status: publishMarkSchema,
+	source: z.union([
+		z.literal("none"),
+		z.literal("publisher"),
+		z.literal("overlay"),
+		z.literal("sync")
+	]),
+	url: z.string().optional(),
+	remoteId: z.string().optional(),
+	views: z.number().optional(),
+	likes: z.number().optional(),
+	comments: z.number().optional(),
+	publishedAt: z.number().optional(),
+	syncedAt: z.number().optional()
+});
+const contentPublishSchema = z.object(Object.fromEntries(PUBLISH_PLATFORMS.map((platform) => [platform, platformPublishSchema])));
+const burnJobSchema = z.object({
+	status: z.union([
+		z.literal("idle"),
+		z.literal("running"),
+		z.literal("done"),
+		z.literal("error")
+	]),
+	startedAt: z.number().optional(),
+	output: z.string().optional(),
+	error: z.string().optional(),
+	pid: z.number().optional()
+});
+const contentSummarySchema = z.object({
+	id: z.string().min(1),
+	folderPath: z.string().min(1),
+	title: z.string(),
+	date: z.string().optional(),
+	recordedAt: z.number(),
+	createdMs: z.number(),
+	videoRaw: z.string().optional(),
+	videoSubtitled: z.string().optional(),
+	covers: contentCoversSchema,
+	subtitles: contentSubtitlesSchema,
+	presentations: contentPresentationsSchema,
+	hasPublishPackage: z.boolean(),
+	hasArticle: z.boolean(),
+	studioPath: z.string().optional(),
+	waitingForExport: z.boolean(),
+	exportTimedOut: z.boolean().optional(),
+	articlePath: z.string().optional(),
+	skippedSteps: z.array(contentOptionalStepSchema).optional(),
+	tags: z.array(z.string()),
+	pipeline: pipelineSchema,
+	workflow: workflowSchema,
+	publish: contentPublishSchema,
+	burn: burnJobSchema,
+	subtitleJob: burnJobSchema,
+	coverJob: burnJobSchema
+});
+const creatorProfileSchema = z.object({ enabledPlatforms: z.array(publishPlatformSchema) });
+const secretViewSchema = z.object({
+	kind: z.union([z.literal("subtitle"), z.literal("cover")]),
+	ref: z.string(),
+	configured: z.boolean(),
+	writable: z.boolean(),
+	source: z.string().optional()
+});
+const librarySettingsSchema = z.object({
+	libraryRoot: z.string(),
+	profile: creatorProfileSchema,
+	secrets: z.object({
+		subtitle: secretViewSchema,
+		cover: secretViewSchema
+	}),
+	scriptRules: z.string().optional()
+});
+const listContentsRequestSchema = z.object({
+	query: z.string(),
+	filter: z.union([
+		z.literal("all"),
+		z.literal("cover"),
+		z.literal("subtitle"),
+		z.literal("article")
+	])
+});
+const listContentsResultSchema = z.object({
+	settings: librarySettingsSchema,
+	items: z.array(contentSummarySchema),
+	counts: z.object({
+		total: z.number().int().nonnegative(),
+		cover: z.number().int().nonnegative(),
+		subtitle: z.number().int().nonnegative(),
+		article: z.number().int().nonnegative()
+	}),
+	revision: z.number().int().nonnegative()
+});
+const idRequestSchema$1 = z.object({ id: z.string().min(1) });
+const contentDetailSchema = contentSummarySchema.and(z.object({
+	publishCopy: z.string(),
+	topicNote: z.string(),
+	script: z.string(),
+	article: z.string(),
+	secrets: z.object({
+		subtitle: secretViewSchema,
+		cover: secretViewSchema
+	})
+}));
+const coverThumbResultSchema = z.object({
+	found: z.boolean(),
+	mime: z.string(),
+	base64: z.string()
+});
+const videoPlaybackResultSchema = z.object({
+	found: z.boolean(),
+	url: z.string(),
+	kind: z.union([z.literal("raw"), z.literal("subtitled")])
+});
+const articleMediaResultSchema = z.object({
+	found: z.boolean(),
+	origin: z.string()
+});
+const subtitleTextResultSchema = z.object({
+	text: z.string(),
+	cues: z.array(z.object({
+		text: z.string(),
+		at: z.string().optional()
+	}))
+});
+const setContentStageRequestSchema = z.object({
+	id: z.string().min(1),
+	readyToRecord: z.boolean()
+});
+const setContentSkipRequestSchema = z.object({
+	id: z.string().min(1),
+	step: contentOptionalStepSchema,
+	skipped: z.boolean()
+});
+const bindStudioRequestSchema = z.object({
+	id: z.string().min(1),
+	path: z.string().min(1)
+});
+const setPublishRequestSchema = z.object({
+	id: z.string().min(1),
+	platform: publishPlatformSchema,
+	status: publishMarkSchema,
+	url: z.string().optional(),
+	publishedAt: z.number().int().nonnegative().optional()
+});
+const subtitlePreviewResultSchema = z.object({
+	url: z.string().min(1),
+	port: z.number().int().positive()
+});
+const syncPublishRequestSchema = z.object({
+	id: z.string().min(1).optional(),
+	platform: publishPlatformSchema.optional(),
+	force: z.boolean().optional()
+});
+const syncPublishResultSchema = z.object({
+	matched: z.number().int().nonnegative(),
+	cached: z.boolean().optional(),
+	platforms: z.array(z.object({
+		platform: publishPlatformSchema,
+		count: z.number().int().nonnegative(),
+		loginRequired: z.boolean().optional(),
+		error: z.string().optional()
+	}))
+});
+const revisionResultSchema = z.object({ revision: z.number().int().nonnegative() });
+const creatorInstallTargetSchema = z.union([
+	z.literal("subtitle"),
+	z.literal("coverBase"),
+	z.literal("editing"),
+	z.literal("publisher")
+]);
+const capabilitySchema = z.object({
+	state: z.union([
+		z.literal("ready"),
+		z.literal("missing"),
+		z.literal("unsupported")
+	]),
+	required: z.boolean(),
+	detail: z.string(),
+	path: z.string().optional(),
+	skillName: z.string().optional(),
+	installTarget: creatorInstallTargetSchema.optional()
+});
+const capabilitiesResultSchema = z.object({ capabilities: z.object({
+	library: capabilitySchema,
+	screenStudio: capabilitySchema,
+	subtitleSkill: capabilitySchema,
+	subtitleCredential: capabilitySchema,
+	coverSkill: capabilitySchema,
+	coverCredential: capabilitySchema,
+	publishSync: capabilitySchema,
+	editingSkill: capabilitySchema,
+	publishSkill: capabilitySchema,
+	presentationSkill: capabilitySchema,
+	articleSkill: capabilitySchema
+}) });
+const installCapabilityRequestSchema = z.object({
+	target: creatorInstallTargetSchema,
+	confirmed: z.literal(true)
+});
+const installCapabilityResultSchema = z.object({
+	target: creatorInstallTargetSchema,
+	changed: z.boolean(),
+	detail: z.string(),
+	capabilities: capabilitiesResultSchema.shape.capabilities
+});
+const platformLoginRequestSchema = z.object({ platforms: z.array(publishPlatformSchema).optional() });
+const platformLoginResultSchema = z.object({ platforms: z.array(z.object({
+	platform: publishPlatformSchema,
+	state: z.union([
+		z.literal("authenticated"),
+		z.literal("loginRequired"),
+		z.literal("unknown"),
+		z.literal("error")
+	]),
+	detail: z.string().optional()
+})) });
+const openPlatformLoginRequestSchema = z.object({ platform: publishPlatformSchema });
+const openPlatformLoginResultSchema = z.object({ opened: z.boolean() });
+const waitExportRequestSchema = z.object({
+	id: z.string().min(1),
+	timeoutMs: z.number().optional()
+});
+const setLibraryRootRequestSchema = z.object({ path: z.string().min(1) });
+const createContentRequestSchema = z.object({ title: z.string().min(1) });
+const createContentResultSchema = z.object({
+	id: z.string().min(1),
+	folderPath: z.string().min(1)
+});
+const setProfileRequestSchema = z.object({ profile: creatorProfileSchema });
+const setScriptRulesRequestSchema = z.object({ text: z.string() });
+const setTopicNoteRequestSchema = z.object({
+	id: z.string().min(1),
+	text: z.string()
+});
+const setScriptRequestSchema = z.object({
+	id: z.string().min(1),
+	text: z.string()
+});
+z.object({
+	apply: z.boolean(),
+	ids: z.array(z.string())
+});
+z.object({
+	moves: z.array(z.object({
+		from: z.string().min(1),
+		to: z.string().min(1),
+		reason: z.union([
+			z.literal("add-date"),
+			z.literal("readable-title"),
+			z.literal("both")
+		])
+	})),
+	unchanged: z.number().int().nonnegative()
+});
+//#endregion
+//#region src/remote-contract.ts
+const PACKAGE_NAME = "jacky-creator";
+const REMOTE_NAMESPACE = "oilCreator";
+const emptyObjectSchema = z.object({});
+function codec$1(typeSymbol, schema) {
+	return {
+		mode: "strict",
+		typeSymbol,
+		schema
+	};
+}
+function jsonParam$1(name, typeSymbol, schema) {
+	return {
+		name,
+		wire: name,
+		source: "json",
+		codec: codec$1(typeSymbol, schema)
+	};
+}
+function invocation$1(method, request, result) {
+	return {
+		id: `${PACKAGE_NAME}#${REMOTE_NAMESPACE}/${method}`,
+		service: REMOTE_NAMESPACE,
+		namespace: REMOTE_NAMESPACE,
+		method,
+		invocation: { kind: "direct" },
+		parameters: [jsonParam$1("request", `${PACKAGE_NAME}#${method}Request`, request)],
+		cancellation: { parameter: "signal" },
+		result: codec$1(`${PACKAGE_NAME}#${method}Result`, result),
+		sourceLocation: {
+			file: "src/service.ts",
+			line: 1,
+			column: 1
+		}
+	};
+}
+const OIL_CREATOR_INVOCATIONS = [
+	invocation$1("listContents", listContentsRequestSchema, listContentsResultSchema),
+	invocation$1("getContent", idRequestSchema$1, contentDetailSchema),
+	invocation$1("getCoverThumb", idRequestSchema$1, coverThumbResultSchema),
+	invocation$1("getVideoPlayback", idRequestSchema$1, videoPlaybackResultSchema),
+	invocation$1("getArticleMedia", idRequestSchema$1, articleMediaResultSchema),
+	invocation$1("getSubtitleText", idRequestSchema$1, subtitleTextResultSchema),
+	invocation$1("getSettings", emptyObjectSchema, librarySettingsSchema),
+	invocation$1("getCapabilities", emptyObjectSchema, capabilitiesResultSchema),
+	invocation$1("installCapability", installCapabilityRequestSchema, installCapabilityResultSchema),
+	invocation$1("checkPlatformLogins", platformLoginRequestSchema, platformLoginResultSchema),
+	invocation$1("openPlatformLogin", openPlatformLoginRequestSchema, openPlatformLoginResultSchema),
+	invocation$1("getRevision", emptyObjectSchema, revisionResultSchema),
+	invocation$1("setLibraryRoot", setLibraryRootRequestSchema, librarySettingsSchema),
+	invocation$1("refreshCatalog", emptyObjectSchema, listContentsResultSchema),
+	invocation$1("createContent", createContentRequestSchema, createContentResultSchema),
+	invocation$1("setContentStage", setContentStageRequestSchema, contentDetailSchema),
+	invocation$1("setContentSkip", setContentSkipRequestSchema, contentDetailSchema),
+	invocation$1("setProfile", setProfileRequestSchema, librarySettingsSchema),
+	invocation$1("setScriptRules", setScriptRulesRequestSchema, librarySettingsSchema),
+	invocation$1("bindStudio", bindStudioRequestSchema, contentDetailSchema),
+	invocation$1("openStudio", idRequestSchema$1, contentDetailSchema),
+	invocation$1("setPublish", setPublishRequestSchema, contentDetailSchema),
+	invocation$1("syncPublish", syncPublishRequestSchema, syncPublishResultSchema),
+	invocation$1("setScript", setScriptRequestSchema, contentDetailSchema),
+	invocation$1("setTopicNote", setTopicNoteRequestSchema, contentDetailSchema),
+	invocation$1("waitForExport", waitExportRequestSchema, contentDetailSchema),
+	invocation$1("openSubtitlePreview", idRequestSchema$1, subtitlePreviewResultSchema),
+	invocation$1("startSubtitleBurn", idRequestSchema$1, contentDetailSchema),
+	invocation$1("startSubtitleGenerate", idRequestSchema$1, contentDetailSchema),
+	invocation$1("startCoverGenerate", idRequestSchema$1, contentDetailSchema)
+];
+const ideaStatusSchema = z.enum([
+	"inbox",
+	"considering",
+	"promoted",
+	"archived"
+]);
+const prioritySchema = z.enum([
+	"low",
+	"normal",
+	"high"
+]);
+const hookTypeSchema = z.enum([
+	"information-gap",
+	"nonconsensus",
+	"pain",
+	"result",
+	"value-promise",
+	"identity",
+	"contrast",
+	"proof",
+	"custom"
+]);
+const structureTypeSchema = z.enum([
+	"pyramid",
+	"problem-cause-solution",
+	"result-method-proof",
+	"pain-misconception-solution",
+	"value-steps-delivery",
+	"comparison-judgment",
+	"story-turn-insight",
+	"list",
+	"case-study",
+	"custom"
+]);
+const scheduleKindSchema = z.enum([
+	"content",
+	"review",
+	"live",
+	"custom"
+]);
+const scheduleMilestoneSchema = z.enum([
+	"topic",
+	"script",
+	"recording",
+	"editing",
+	"publishing",
+	"review",
+	"custom"
+]);
+const knowledgeKindSchema = z.enum(["rule", "template"]);
+const goalMetricSchema = z.enum([
+	"published",
+	"views",
+	"likes",
+	"comments",
+	"followers",
+	"custom"
+]);
+const evaluationScoresSchema = z.object({
+	audience: z.number().int().min(0).max(5),
+	pain: z.number().int().min(0).max(5),
+	differentiation: z.number().int().min(0).max(5),
+	assets: z.number().int().min(0).max(5),
+	hook: z.number().int().min(0).max(5),
+	structure: z.number().int().min(0).max(5)
+}).strict();
+const contentEvaluationSchema = z.object({
+	id: z.string().min(1),
+	contentId: z.string().min(1),
+	rubricVersion: z.string().min(1),
+	scores: evaluationScoresSchema,
+	total: z.number().int().min(0).max(30),
+	evidence: z.record(z.string(), z.string()),
+	suggestions: z.array(z.string()),
+	inputFingerprint: z.string().min(1),
+	createdAt: z.number().int().nonnegative(),
+	confirmedAt: z.number().int().nonnegative().optional()
+}).strict().superRefine((evaluation, context) => {
+	const total = Object.values(evaluation.scores).reduce((sum, score) => sum + score, 0);
+	if (evaluation.total !== total) context.addIssue({
+		code: "custom",
+		message: "evaluation total must equal score sum",
+		path: ["total"]
+	});
+});
+const contentReviewSchema = z.object({
+	id: z.string().min(1),
+	contentId: z.string().min(1),
+	status: z.enum(["draft", "confirmed"]),
+	rating: z.number().int().min(1).max(5).optional(),
+	analysis: z.string(),
+	learnedRule: z.string().optional(),
+	inputFingerprint: z.string().min(1),
+	createdAt: z.number().int().nonnegative(),
+	confirmedAt: z.number().int().nonnegative().optional()
+}).strict().superRefine((review, context) => {
+	if (review.status === "confirmed" && review.confirmedAt === void 0) context.addIssue({
+		code: "custom",
+		message: "confirmed review requires confirmedAt",
+		path: ["confirmedAt"]
+	});
+	if (review.status === "draft" && review.confirmedAt !== void 0) context.addIssue({
+		code: "custom",
+		message: "draft review cannot have confirmedAt",
+		path: ["confirmedAt"]
+	});
+});
+const supplementalMetricsSchema = z.object({
+	saves: z.number().int().nonnegative().optional(),
+	followerGain: z.number().int().optional(),
+	clickRate: z.number().min(0).max(100).optional(),
+	retentionRate: z.number().min(0).max(100).optional(),
+	note: z.string().optional()
+}).strict();
+const ideaSchema = z.object({
+	id: z.string().min(1),
+	title: z.string().min(1),
+	note: z.string(),
+	source: z.string().optional(),
+	tags: z.array(z.string()),
+	contentType: z.string().optional(),
+	tier: z.string().optional(),
+	status: ideaStatusSchema,
+	goalId: z.string().min(1).optional(),
+	promotedContentId: z.string().min(1).optional(),
+	createdAt: z.number().int().nonnegative(),
+	updatedAt: z.number().int().nonnegative()
+}).strict();
+const contentOperationsMetaSchema = z.object({
+	contentId: z.string().min(1),
+	contentType: z.string().optional(),
+	tier: z.string().optional(),
+	priority: prioritySchema.optional(),
+	nextAction: z.string().optional(),
+	tags: z.array(z.string()),
+	hookType: hookTypeSchema.optional(),
+	customHook: z.string().optional(),
+	structureType: structureTypeSchema.optional(),
+	customStructure: z.string().optional(),
+	knowledgeIds: z.array(z.string().min(1)),
+	goalIds: z.array(z.string().min(1)),
+	supplementalMetrics: supplementalMetricsSchema.optional(),
+	evaluations: z.array(contentEvaluationSchema),
+	reviews: z.array(contentReviewSchema),
+	updatedAt: z.number().int().nonnegative()
+}).strict();
+const scheduleItemSchema = z.object({
+	id: z.string().min(1),
+	kind: scheduleKindSchema,
+	milestone: scheduleMilestoneSchema,
+	title: z.string().min(1),
+	contentId: z.string().min(1).optional(),
+	typeId: z.string().min(1).optional(),
+	plannedAt: z.number().int().nonnegative(),
+	rank: z.number().int().nonnegative(),
+	completedAt: z.number().int().nonnegative().optional(),
+	note: z.string(),
+	createdAt: z.number().int().nonnegative(),
+	updatedAt: z.number().int().nonnegative()
+}).strict();
+const knowledgeItemSchema = z.object({
+	id: z.string().min(1),
+	kind: knowledgeKindSchema,
+	title: z.string().min(1),
+	body: z.string().min(1),
+	tags: z.array(z.string()),
+	sourceContentId: z.string().min(1),
+	sourceReviewId: z.string().min(1),
+	markdownPath: z.string().min(1),
+	active: z.boolean(),
+	createdAt: z.number().int().nonnegative(),
+	updatedAt: z.number().int().nonnegative()
+}).strict();
+const goalSchema = z.object({
+	id: z.string().min(1),
+	name: z.string().min(1),
+	metric: goalMetricSchema,
+	target: z.number().nonnegative(),
+	manualCurrent: z.number().optional(),
+	startAt: z.number().int().nonnegative(),
+	endAt: z.number().int().nonnegative(),
+	contentIds: z.array(z.string().min(1)),
+	primary: z.boolean(),
+	contentTypeTargets: z.array(z.object({
+		contentType: z.string().trim().min(1).max(120),
+		target: z.number().int().nonnegative()
+	}).strict()),
+	followerStart: z.number().int().nonnegative().optional(),
+	followerTarget: z.number().int().nonnegative().optional(),
+	archivedAt: z.number().int().nonnegative().optional(),
+	note: z.string(),
+	createdAt: z.number().int().nonnegative(),
+	updatedAt: z.number().int().nonnegative()
+}).strict().superRefine((goal, context) => {
+	if (goal.endAt < goal.startAt) context.addIssue({
+		code: "custom",
+		message: "endAt must not be earlier than startAt",
+		path: ["endAt"]
+	});
+	if (goal.metric !== "custom" && goal.manualCurrent !== void 0) context.addIssue({
+		code: "custom",
+		message: "manualCurrent is only valid for custom goals",
+		path: ["manualCurrent"]
+	});
+	const quotaTotal = goal.contentTypeTargets.reduce((sum, item) => sum + item.target, 0);
+	if (goal.primary && quotaTotal > goal.target) context.addIssue({
+		code: "custom",
+		message: "content type targets cannot exceed the output target",
+		path: ["contentTypeTargets"]
+	});
+});
+const followerSnapshotSchema = z.object({
+	id: z.string().min(1),
+	followers: z.number().int().nonnegative(),
+	capturedAt: z.number().int().nonnegative(),
+	note: z.string().optional()
+}).strict();
+const scheduleTypeSchema = z.object({
+	id: z.string().trim().min(1).max(80),
+	name: z.string().trim().min(1).max(120),
+	color: z.string().regex(/^#[0-9a-f]{6}$/i),
+	archived: z.boolean()
+}).strict();
+const milestoneColorsSchema = z.object({
+	topic: z.string().regex(/^#[0-9a-f]{6}$/i),
+	script: z.string().regex(/^#[0-9a-f]{6}$/i),
+	recording: z.string().regex(/^#[0-9a-f]{6}$/i),
+	editing: z.string().regex(/^#[0-9a-f]{6}$/i),
+	publishing: z.string().regex(/^#[0-9a-f]{6}$/i),
+	review: z.string().regex(/^#[0-9a-f]{6}$/i),
+	custom: z.string().regex(/^#[0-9a-f]{6}$/i)
+}).strict();
+const cockpitSettingsSchema = z.object({
+	reviewDelayDays: z.number().int().min(0).max(30),
+	contentTypes: z.array(z.string().trim().min(1).max(120)).max(100),
+	tiers: z.array(z.string().trim().min(1).max(80)).max(100),
+	tags: z.array(z.string().trim().min(1).max(80)).max(300),
+	scheduleTypes: z.array(scheduleTypeSchema).max(100),
+	milestoneColors: milestoneColorsSchema
+}).strict();
+const cockpitStateSchema = z.object({
+	schemaVersion: z.literal(3),
+	revision: z.number().int().nonnegative(),
+	ideas: z.array(ideaSchema),
+	contentMeta: z.record(z.string(), contentOperationsMetaSchema),
+	goals: z.array(goalSchema),
+	followerSnapshots: z.array(followerSnapshotSchema),
+	scheduleItems: z.array(scheduleItemSchema),
+	knowledgeItems: z.array(knowledgeItemSchema),
+	settings: cockpitSettingsSchema
+}).strict().superRefine((state, context) => {
+	const goalIds = new Set(state.goals.map((goal) => goal.id));
+	const uniqueIds = (values, path) => {
+		if (new Set(values).size !== values.length) context.addIssue({
+			code: "custom",
+			message: "ids must be unique",
+			path
+		});
+	};
+	uniqueIds(state.ideas.map((idea) => idea.id), ["ideas"]);
+	uniqueIds(state.goals.map((goal) => goal.id), ["goals"]);
+	uniqueIds(state.followerSnapshots.map((snapshot) => snapshot.id), ["followerSnapshots"]);
+	uniqueIds(state.scheduleItems.map((item) => item.id), ["scheduleItems"]);
+	uniqueIds(state.knowledgeItems.map((item) => item.id), ["knowledgeItems"]);
+	uniqueIds(state.settings.scheduleTypes.map((item) => item.id), ["settings", "scheduleTypes"]);
+	if (state.goals.filter((goal) => goal.primary && goal.archivedAt === void 0).length > 1) context.addIssue({
+		code: "custom",
+		message: "only one active primary goal is allowed",
+		path: ["goals"]
+	});
+	const knowledgeIds = new Set(state.knowledgeItems.map((item) => item.id));
+	for (const [index, idea] of state.ideas.entries()) {
+		if (idea.goalId !== void 0 && !goalIds.has(idea.goalId)) context.addIssue({
+			code: "custom",
+			message: "idea goalId must reference a goal",
+			path: [
+				"ideas",
+				index,
+				"goalId"
+			]
+		});
+		if (idea.status === "promoted" !== (idea.promotedContentId !== void 0)) context.addIssue({
+			code: "custom",
+			message: "promoted status and promotedContentId must agree",
+			path: [
+				"ideas",
+				index,
+				"promotedContentId"
+			]
+		});
+	}
+	for (const [key, meta] of Object.entries(state.contentMeta)) {
+		if (key !== meta.contentId) context.addIssue({
+			code: "custom",
+			message: "contentMeta key must match contentId",
+			path: [
+				"contentMeta",
+				key,
+				"contentId"
+			]
+		});
+		uniqueIds(meta.goalIds, [
+			"contentMeta",
+			key,
+			"goalIds"
+		]);
+		uniqueIds(meta.evaluations.map((evaluation) => evaluation.id), [
+			"contentMeta",
+			key,
+			"evaluations"
+		]);
+		uniqueIds(meta.reviews.map((review) => review.id), [
+			"contentMeta",
+			key,
+			"reviews"
+		]);
+		uniqueIds(meta.tags, [
+			"contentMeta",
+			key,
+			"tags"
+		]);
+		uniqueIds(meta.knowledgeIds, [
+			"contentMeta",
+			key,
+			"knowledgeIds"
+		]);
+		for (const goalId of meta.goalIds) if (!goalIds.has(goalId)) context.addIssue({
+			code: "custom",
+			message: "content goalId must reference a goal",
+			path: [
+				"contentMeta",
+				key,
+				"goalIds"
+			]
+		});
+		for (const knowledgeId of meta.knowledgeIds) if (!knowledgeIds.has(knowledgeId)) context.addIssue({
+			code: "custom",
+			message: "content knowledgeId must reference knowledge",
+			path: [
+				"contentMeta",
+				key,
+				"knowledgeIds"
+			]
+		});
+	}
+});
+const createIdeaRequestSchema = z.object({
+	title: z.string().trim().min(1).max(240),
+	note: z.string().max(2e4),
+	source: z.string().max(2e3).optional(),
+	tags: z.array(z.string().trim().min(1).max(80)).max(50),
+	contentType: z.string().trim().min(1).max(120).optional(),
+	tier: z.string().trim().min(1).max(80).optional(),
+	goalId: z.string().min(1).optional()
+}).strict();
+const updateIdeaRequestSchema = z.object({
+	id: z.string().min(1),
+	patch: z.object({
+		title: z.string().trim().min(1).max(240).optional(),
+		note: z.string().max(2e4).optional(),
+		source: z.string().max(2e3).nullable().optional(),
+		tags: z.array(z.string().trim().min(1).max(80)).max(50).optional(),
+		contentType: z.string().trim().min(1).max(120).nullable().optional(),
+		tier: z.string().trim().min(1).max(80).nullable().optional(),
+		status: z.enum([
+			"inbox",
+			"considering",
+			"archived"
+		]).optional(),
+		goalId: z.string().min(1).nullable().optional()
+	}).strict()
+}).strict();
+const idRequestSchema = z.object({ id: z.string().min(1) }).strict();
+const setContentMetaRequestSchema = z.object({
+	contentId: z.string().min(1),
+	patch: z.object({
+		contentType: z.string().max(120).nullable().optional(),
+		tier: z.string().max(80).nullable().optional(),
+		priority: prioritySchema.nullable().optional(),
+		nextAction: z.string().max(2e3).nullable().optional(),
+		tags: z.array(z.string().trim().min(1).max(80)).max(100).optional(),
+		hookType: hookTypeSchema.nullable().optional(),
+		customHook: z.string().max(2e3).nullable().optional(),
+		structureType: structureTypeSchema.nullable().optional(),
+		customStructure: z.string().max(2e3).nullable().optional(),
+		knowledgeIds: z.array(z.string().min(1)).max(200).optional(),
+		goalIds: z.array(z.string().min(1)).max(100).optional(),
+		supplementalMetrics: supplementalMetricsSchema.nullable().optional()
+	}).strict()
+}).strict();
+const createGoalRequestSchema = z.object({
+	name: z.string().trim().min(1).max(240),
+	metric: goalMetricSchema,
+	target: z.number().nonnegative(),
+	manualCurrent: z.number().optional(),
+	startAt: z.number().int().nonnegative(),
+	endAt: z.number().int().nonnegative(),
+	contentIds: z.array(z.string().min(1)).max(500),
+	primary: z.boolean().optional(),
+	contentTypeTargets: z.array(z.object({
+		contentType: z.string().trim().min(1).max(120),
+		target: z.number().int().nonnegative()
+	}).strict()).max(100).optional(),
+	followerStart: z.number().int().nonnegative().optional(),
+	followerTarget: z.number().int().nonnegative().optional(),
+	note: z.string().max(2e4)
+}).strict().superRefine((goal, context) => {
+	if (goal.endAt < goal.startAt) context.addIssue({
+		code: "custom",
+		message: "endAt must not be earlier than startAt",
+		path: ["endAt"]
+	});
+	if (goal.metric !== "custom" && goal.manualCurrent !== void 0) context.addIssue({
+		code: "custom",
+		message: "manualCurrent is only valid for custom goals",
+		path: ["manualCurrent"]
+	});
+});
+const updateGoalRequestSchema = z.object({
+	id: z.string().min(1),
+	patch: z.object({
+		name: z.string().min(1).max(240).optional(),
+		target: z.number().nonnegative().optional(),
+		manualCurrent: z.number().nullable().optional(),
+		startAt: z.number().int().nonnegative().optional(),
+		endAt: z.number().int().nonnegative().optional(),
+		contentIds: z.array(z.string().min(1)).max(500).optional(),
+		primary: z.boolean().optional(),
+		contentTypeTargets: z.array(z.object({
+			contentType: z.string().trim().min(1).max(120),
+			target: z.number().int().nonnegative()
+		}).strict()).max(100).optional(),
+		followerStart: z.number().int().nonnegative().nullable().optional(),
+		followerTarget: z.number().int().nonnegative().nullable().optional(),
+		archived: z.boolean().optional(),
+		note: z.string().max(2e4).optional()
+	}).strict()
+}).strict();
+const createFollowerSnapshotRequestSchema = followerSnapshotSchema.pick({
+	followers: true,
+	capturedAt: true,
+	note: true
+}).strict();
+const createScheduleItemRequestSchema = scheduleItemSchema.pick({
+	kind: true,
+	milestone: true,
+	title: true,
+	contentId: true,
+	typeId: true,
+	plannedAt: true,
+	rank: true,
+	note: true
+}).extend({ rank: z.number().int().nonnegative().optional() }).strict();
+const updateScheduleItemRequestSchema = z.object({
+	id: z.string().min(1),
+	patch: z.object({
+		kind: scheduleKindSchema.optional(),
+		milestone: scheduleMilestoneSchema.optional(),
+		title: z.string().trim().min(1).max(240).optional(),
+		contentId: z.string().min(1).nullable().optional(),
+		typeId: z.string().min(1).nullable().optional(),
+		plannedAt: z.number().int().nonnegative().optional(),
+		rank: z.number().int().nonnegative().optional(),
+		completed: z.boolean().optional(),
+		note: z.string().max(2e4).optional()
+	}).strict()
+}).strict();
+const updateCockpitSettingsRequestSchema = z.object({
+	reviewDelayDays: z.number().int().min(0).max(30).optional(),
+	contentTypes: z.array(z.string().trim().min(1).max(120)).max(100).optional(),
+	tiers: z.array(z.string().trim().min(1).max(80)).max(100).optional(),
+	tags: z.array(z.string().trim().min(1).max(80)).max(300).optional(),
+	scheduleTypes: z.array(scheduleTypeSchema).max(100).optional(),
+	milestoneColors: milestoneColorsSchema.optional()
+}).strict();
+const restoreCockpitStateRequestSchema = z.object({
+	expectedRevision: z.number().int().nonnegative(),
+	state: z.unknown()
+}).strict();
+z.object({
+	contentId: z.string().min(1),
+	rubricVersion: z.string().min(1),
+	scores: evaluationScoresSchema,
+	evidence: z.record(z.string(), z.string().max(1e4)),
+	suggestions: z.array(z.string().max(1e4)).max(50),
+	inputFingerprint: z.string().min(1)
+}).strict();
+const saveManualReviewDraftRequestSchema = z.object({
+	contentId: z.string().min(1),
+	rating: z.number().int().min(1).max(5).optional(),
+	analysis: z.string().min(1).max(5e4),
+	learnedRule: z.string().max(2e4).optional(),
+	inputFingerprint: z.string().min(1)
+}).strict().omit({ inputFingerprint: true });
+const contentRecordRequestSchema = z.object({
+	contentId: z.string().min(1),
+	id: z.string().min(1)
+}).strict();
+const promoteIdeaRequestSchema = z.object({
+	ideaId: z.string().min(1),
+	expectedRevision: z.number().int().nonnegative(),
+	title: z.string().trim().min(1).max(240),
+	topicNote: z.string().max(5e4)
+}).strict();
+const knowledgeRequestSchema = z.object({
+	contentId: z.string().min(1),
+	reviewId: z.string().min(1),
+	title: z.string().trim().min(1).max(240),
+	body: z.string().min(1).max(5e4),
+	tags: z.array(z.string().trim().min(1).max(80)).max(50).optional()
+}).strict();
+const updateKnowledgeRequestSchema = z.object({
+	id: z.string().min(1),
+	patch: z.object({
+		title: z.string().trim().min(1).max(240).optional(),
+		body: z.string().min(1).max(5e4).optional(),
+		tags: z.array(z.string().trim().min(1).max(80)).max(50).optional(),
+		active: z.boolean().optional()
+	}).strict()
+}).strict();
+const promotionResultSchema = z.object({
+	state: cockpitStateSchema,
+	contentId: z.string().min(1),
+	folderPath: z.string().min(1).optional(),
+	topicWritten: z.boolean(),
+	recovery: z.string().optional()
+}).strict();
+const knowledgeResultSchema = z.object({
+	state: cockpitStateSchema,
+	path: z.string().min(1),
+	entryId: z.string().min(1)
+}).strict();
+const cockpitRevisionSchema = z.object({ revision: z.number().int().nonnegative() }).strict();
+const emptyRequestSchema = z.object({}).strict();
+//#endregion
+//#region src/cockpit/remote-contract.ts
+const CREATOR_COCKPIT_NAMESPACE = "creatorCockpit";
+function codec(typeSymbol, schema) {
+	return {
+		mode: "strict",
+		typeSymbol,
+		schema
+	};
+}
+function jsonParam(name, typeSymbol, schema) {
+	return {
+		name,
+		wire: name,
+		source: "json",
+		codec: codec(typeSymbol, schema)
+	};
+}
+function invocation(method, request, result) {
+	return {
+		id: `${PACKAGE_NAME}#${CREATOR_COCKPIT_NAMESPACE}/${method}`,
+		service: CREATOR_COCKPIT_NAMESPACE,
+		namespace: CREATOR_COCKPIT_NAMESPACE,
+		method,
+		invocation: { kind: "direct" },
+		parameters: [jsonParam("request", `${PACKAGE_NAME}#cockpit/${method}Request`, request)],
+		cancellation: { parameter: "signal" },
+		result: codec(`${PACKAGE_NAME}#cockpit/${method}Result`, result),
+		sourceLocation: {
+			file: "src/cockpit/service.ts",
+			line: 1,
+			column: 1
+		}
+	};
+}
+const CREATOR_COCKPIT_INVOCATIONS = [
+	invocation("getState", emptyRequestSchema, cockpitStateSchema),
+	invocation("getRevision", emptyRequestSchema, cockpitRevisionSchema),
+	invocation("restoreState", restoreCockpitStateRequestSchema, cockpitStateSchema),
+	invocation("createIdea", createIdeaRequestSchema, cockpitStateSchema),
+	invocation("updateIdea", updateIdeaRequestSchema, cockpitStateSchema),
+	invocation("deleteIdea", idRequestSchema, cockpitStateSchema),
+	invocation("setContentMeta", setContentMetaRequestSchema, cockpitStateSchema),
+	invocation("deleteContentMeta", idRequestSchema, cockpitStateSchema),
+	invocation("createGoal", createGoalRequestSchema, cockpitStateSchema),
+	invocation("updateGoal", updateGoalRequestSchema, cockpitStateSchema),
+	invocation("deleteGoal", idRequestSchema, cockpitStateSchema),
+	invocation("createFollowerSnapshot", createFollowerSnapshotRequestSchema, cockpitStateSchema),
+	invocation("deleteFollowerSnapshot", idRequestSchema, cockpitStateSchema),
+	invocation("createScheduleItem", createScheduleItemRequestSchema, cockpitStateSchema),
+	invocation("updateScheduleItem", updateScheduleItemRequestSchema, cockpitStateSchema),
+	invocation("deleteScheduleItem", idRequestSchema, cockpitStateSchema),
+	invocation("updateSettings", updateCockpitSettingsRequestSchema, cockpitStateSchema),
+	invocation("saveManualReviewDraft", saveManualReviewDraftRequestSchema, cockpitStateSchema),
+	invocation("confirmReview", contentRecordRequestSchema, cockpitStateSchema),
+	invocation("saveRule", knowledgeRequestSchema, knowledgeResultSchema),
+	invocation("saveTemplate", knowledgeRequestSchema, knowledgeResultSchema),
+	invocation("updateKnowledge", updateKnowledgeRequestSchema, cockpitStateSchema),
+	invocation("promoteIdea", promoteIdeaRequestSchema, promotionResultSchema)
+];
+//#endregion
+//#region src/typert.host.ts
+const ALL_INVOCATIONS = [...OIL_CREATOR_INVOCATIONS, ...CREATOR_COCKPIT_INVOCATIONS];
+const TYPERT = {
+	package: PACKAGE_NAME,
+	face: "host",
+	schemas: [],
+	model: {
+		services: [],
+		events: [],
+		objects: []
+	},
+	invocations: ALL_INVOCATIONS
+};
+//#endregion
+export { ALL_INVOCATIONS, TYPERT };