@openspecui/core 4.1.0 → 6.0.0-beta.0

package/dist/spec-catalog-ZGuiZ4CE.mjs

@@ -0,0 +1,901 @@
+import { l as SpecSchema } from "./schemas-BFroDdOC.mjs";
+import { a as CliRootSchema, i as CliReferenceIndexEntrySchema, n as CliDiagnosticSchema, r as CliDoctorReferenceEntrySchema, t as CliDiagnosticFailureSchema } from "./common-D8YUK9dA.mjs";
+import { r as CliProjectionCommandEvidenceSchema } from "./cli-projection-vO3-FJg5.mjs";
+import { z } from "zod";
+import { match } from "ts-pattern";
+
+//#region src/cli-contracts/command-result.ts
+/**
+* Orthogonal intents (created 2026-07-15 Asia/Shanghai):
+* 1. Preserve every process-level fact from an OpenSpec CLI invocation.
+* 2. Validate command payloads without discarding the raw JSON document.
+* 3. Surface contract drift separately from CLI command failure.
+*
+* Original request (2026-07-15): "对新增字段保持可扩展，对必需语义严格验证。"
+*/
+function formatContractError(error) {
+	return error.issues.map((issue) => {
+		return `${issue.path.length > 0 ? issue.path.join(".") : "<root>"}: ${issue.message}`;
+	}).join("; ");
+}
+function extractDiagnostics(payload) {
+	if (typeof payload !== "object" || payload === null || !("status" in payload)) return [];
+	const parsed = z.array(CliDiagnosticSchema).safeParse(payload.status);
+	return parsed.success ? parsed.data : [];
+}
+/** Parse one CLI JSON document while retaining all process and raw-payload evidence. */
+function parseCliCommandResult(result, schema) {
+	let payload;
+	try {
+		payload = JSON.parse(result.stdout);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			...result,
+			data: null,
+			payload: null,
+			diagnostics: [],
+			contractError: `OpenSpec CLI stdout is not one JSON document: ${message}`
+		};
+	}
+	const parsed = schema.safeParse(payload);
+	if (!parsed.success) return {
+		...result,
+		data: null,
+		payload,
+		diagnostics: extractDiagnostics(payload),
+		contractError: formatContractError(parsed.error)
+	};
+	return {
+		...result,
+		data: parsed.data,
+		payload,
+		diagnostics: extractDiagnostics(parsed.data)
+	};
+}
+
+//#endregion
+//#region src/cli-contracts/store.ts
+/**
+* Orthogonal intents (created 2026-07-15 Asia/Shanghai):
+* 1. Model the snake_case Store command family.
+* 2. Model root Doctor and Context relationship projections.
+* 3. Preserve healthy empty Stores and diagnostic failure null-shapes.
+*
+* Original request (2026-07-15): "Store/Context/Doctor 的 snake_case 与 workflow 的 camelCase 必须按官方合同处理。"
+*/
+/** Registered Store identity and canonical root emitted by the CLI. */
+const CliStoreSchema = z.object({
+	id: z.string(),
+	root: z.string(),
+	metadata_path: z.string().optional()
+}).passthrough();
+/** Strict typed result of the CLI Store-list JSON command. */
+const CliStoreListSchema = z.object({
+	stores: z.array(CliStoreSchema),
+	status: z.array(CliDiagnosticSchema)
+}).passthrough();
+const CliStoreRegistryMutationSchema = z.object({
+	path: z.string(),
+	registered: z.boolean(),
+	already_registered: z.boolean()
+}).passthrough();
+const CliStoreGitMutationSchema = z.object({
+	is_repository: z.boolean(),
+	initialized: z.boolean(),
+	committed: z.boolean()
+}).passthrough();
+/** Strict Store setup/register mutation result. */
+const CliStoreMutationSchema = z.object({
+	store: CliStoreSchema.nullable(),
+	registry: CliStoreRegistryMutationSchema.nullable(),
+	git: CliStoreGitMutationSchema.nullable(),
+	created_files: z.array(z.string()),
+	status: z.array(CliDiagnosticSchema)
+}).passthrough();
+const CliStoreRegistryCleanupSchema = z.object({
+	path: z.string(),
+	removed: z.boolean()
+}).passthrough();
+const CliStoreFilesCleanupSchema = z.object({
+	deleted: z.boolean(),
+	deleted_path: z.string().nullable(),
+	left_on_disk: z.string().nullable()
+}).passthrough();
+/** Strict Store unregister/remove cleanup result. */
+const CliStoreCleanupSchema = z.object({
+	store: CliStoreSchema.nullable(),
+	registry: CliStoreRegistryCleanupSchema.nullable(),
+	files: CliStoreFilesCleanupSchema.nullable(),
+	status: z.array(CliDiagnosticSchema)
+}).passthrough();
+const CliPresenceSchema = z.object({ present: z.boolean().nullable() }).passthrough();
+const CliOpenSpecRootInspectionSchema = z.object({
+	present: z.boolean().nullable(),
+	config: CliPresenceSchema,
+	specs: CliPresenceSchema,
+	changes: CliPresenceSchema,
+	archive: CliPresenceSchema,
+	healthy: z.boolean(),
+	status: z.array(CliDiagnosticSchema)
+}).passthrough();
+const CliStoreMetadataSchema = z.object({
+	present: z.boolean().nullable(),
+	valid: z.boolean().nullable(),
+	id: z.string().nullable().optional(),
+	remote: z.string().nullable().optional()
+}).passthrough();
+const CliStoreGitInspectionSchema = z.object({
+	is_repository: z.boolean().nullable(),
+	has_commits: z.boolean().nullable(),
+	has_uncommitted_changes: z.boolean().nullable(),
+	has_remote: z.boolean().nullable(),
+	origin_url: z.string().nullable()
+}).passthrough();
+/** Strict Doctor facts for one registered Store. */
+const CliStoreDoctorEntrySchema = CliStoreSchema.extend({
+	openspec_root: CliOpenSpecRootInspectionSchema,
+	metadata: CliStoreMetadataSchema,
+	git: CliStoreGitInspectionSchema,
+	status: z.array(CliDiagnosticSchema)
+}).passthrough();
+/** Strict typed result of the CLI Store Doctor JSON command. */
+const CliStoreDoctorSchema = z.object({
+	stores: z.array(CliStoreDoctorEntrySchema),
+	status: z.array(CliDiagnosticSchema)
+}).passthrough();
+const CliDoctorRootSchema = CliRootSchema.extend({
+	healthy: z.boolean(),
+	status: z.array(CliDiagnosticSchema)
+}).passthrough();
+const CliDoctorStoreSchema = z.object({
+	id: z.string(),
+	metadata: CliStoreMetadataSchema,
+	origin_url: z.string().optional(),
+	status: z.array(CliDiagnosticSchema)
+}).passthrough();
+/** Root, Store, Reference, and diagnostic result of CLI Doctor. */
+const CliDoctorSchema = z.object({
+	root: CliDoctorRootSchema.nullable(),
+	store: CliDoctorStoreSchema.nullable(),
+	references: z.array(CliDoctorReferenceEntrySchema),
+	status: z.array(CliDiagnosticSchema)
+}).passthrough();
+const CliContextRootSchema = CliRootSchema.extend({ role: z.literal("openspec_root") }).passthrough();
+const CliContextMemberSchema = z.object({
+	role: z.literal("referenced_store"),
+	id: z.string(),
+	path: z.string().optional(),
+	remote: z.string().optional(),
+	fetch: z.string().optional(),
+	status: z.array(CliDiagnosticSchema)
+}).passthrough();
+/** Root and direct referenced-Store relationship result of CLI Context. */
+const CliContextSchema = z.object({
+	root: CliContextRootSchema.nullable(),
+	members: z.array(CliContextMemberSchema),
+	status: z.array(CliDiagnosticSchema)
+}).passthrough();
+/** Known JSON documents that a Store-family command may emit on failure. */
+const CliStoreCommandFailureSchema = z.union([
+	CliStoreMutationSchema,
+	CliStoreCleanupSchema,
+	CliStoreListSchema,
+	CliStoreDoctorSchema,
+	CliDiagnosticFailureSchema
+]);
+
+//#endregion
+//#region src/cli-contracts/workflow.ts
+/**
+* Orthogonal intents (updated 2026-07-26 Asia/Shanghai):
+* 1. Model camelCase workflow JSON independently from Store-family JSON.
+* 2. Preserve strict validate and archive outcomes, including failure payloads.
+* 3. Preserve multiline requirement bodies from `show --json`.
+* 4. Preserve complete OpenSpec 1.6 Status/Instructions action contracts as CLI facts.
+* 5. Export the successful Spec-document schema for browser-safe projection validation.
+*
+* Original request (2026-07-15): "为不同命令建立强类型适配器，不实现平行解析规则。"
+* Original request (2026-07-26): "展开全面的接口升级和内核升级和测试升级。"
+*/
+const CliChangeListEntrySchema = z.object({
+	name: z.string(),
+	completedTasks: z.number(),
+	totalTasks: z.number(),
+	lastModified: z.string(),
+	status: z.enum([
+		"no-tasks",
+		"complete",
+		"in-progress"
+	])
+}).passthrough();
+/** Typed result of the CLI change-list JSON command. */
+const CliChangeListSchema = z.object({
+	changes: z.array(CliChangeListEntrySchema),
+	root: CliRootSchema.nullable(),
+	status: z.array(CliDiagnosticSchema).optional()
+}).passthrough();
+const CliSpecListEntrySchema = z.object({
+	id: z.string(),
+	requirementCount: z.number()
+}).passthrough();
+/** Typed result of the CLI Spec-list JSON command. */
+const CliSpecListSchema = z.object({
+	specs: z.array(CliSpecListEntrySchema),
+	root: CliRootSchema.nullable(),
+	status: z.array(CliDiagnosticSchema).optional()
+}).passthrough();
+/** One workflow schema discovered by the CLI-selected OpenSpec runtime. */
+const CliSchemaInfoSchema = z.object({
+	name: z.string(),
+	description: z.string().optional(),
+	artifacts: z.array(z.string()),
+	source: z.enum([
+		"project",
+		"user",
+		"package"
+	])
+}).passthrough();
+/** Typed result of `openspec schemas --json`. */
+const CliSchemasSchema = z.array(CliSchemaInfoSchema);
+/** CLI resolution for one schema, including lower-priority shadows. */
+const CliSchemaShadowSchema = z.object({
+	source: z.enum([
+		"project",
+		"user",
+		"package"
+	]),
+	path: z.string()
+}).passthrough();
+const CliSchemaResolutionSchema = z.object({
+	name: z.string(),
+	source: z.enum([
+		"project",
+		"user",
+		"package"
+	]),
+	path: z.string(),
+	shadows: z.array(CliSchemaShadowSchema)
+}).passthrough();
+/** Typed result of `openspec schema which <name> --json`. */
+const CliSchemaWhichSchema = CliSchemaResolutionSchema;
+/** Typed result of `openspec templates --json [--schema <name>]`. */
+const CliTemplateEntrySchema = z.object({
+	path: z.string(),
+	source: z.enum([
+		"project",
+		"user",
+		"package"
+	])
+}).passthrough();
+const CliTemplatesSchema = z.record(CliTemplateEntrySchema);
+const CliSpecRequirementSchema = z.object({
+	text: z.string(),
+	scenarios: z.array(z.object({ rawText: z.string() }).passthrough())
+}).passthrough();
+/** Typed successful document returned by the CLI show-Spec JSON command. */
+const CliShowSpecDocumentSchema = z.object({
+	id: z.string(),
+	title: z.string(),
+	overview: z.string(),
+	requirementCount: z.number(),
+	requirements: z.array(CliSpecRequirementSchema),
+	metadata: z.object({
+		version: z.string(),
+		format: z.string(),
+		sourcePath: z.string().optional()
+	}).passthrough(),
+	root: CliRootSchema
+}).passthrough();
+/** Typed success or diagnostic failure result of the CLI show-Spec JSON command. */
+const CliShowSpecSchema = z.union([CliShowSpecDocumentSchema, CliDiagnosticFailureSchema]);
+/** CLI-resolved output and existing paths for one workflow artifact. */
+const CliArtifactPathSchema = z.object({
+	outputPath: z.string(),
+	resolvedOutputPath: z.string(),
+	existingOutputPaths: z.array(z.string())
+}).passthrough();
+/** Repository-local planning home selected by the CLI workflow engine. */
+const CliPlanningHomeSchema = z.object({
+	kind: z.literal("repo"),
+	root: z.string(),
+	changesDir: z.string(),
+	defaultSchema: z.string()
+}).passthrough();
+/** CLI-owned action boundaries and edit constraints for a workflow. */
+const CliActionContextSchema = z.object({
+	mode: z.literal("repo-local"),
+	sourceOfTruth: z.literal("repo"),
+	planningArtifacts: z.array(z.string()),
+	linkedContext: z.array(z.object({ name: z.string() }).passthrough()),
+	allowedEditRoots: z.array(z.string()),
+	requiresAffectedAreaSelection: z.boolean(),
+	constraints: z.array(z.string())
+}).passthrough();
+const CliStatusArtifactSchema = z.object({
+	id: z.string(),
+	outputPath: z.string(),
+	status: z.enum([
+		"done",
+		"ready",
+		"blocked"
+	]),
+	missingDeps: z.array(z.string()).optional()
+}).passthrough();
+/** Complete successful Status payload for one OpenSpec change. */
+const CliWorkflowStatusSuccessSchema = z.object({
+	changeName: z.string(),
+	schemaName: z.string(),
+	planningHome: CliPlanningHomeSchema,
+	changeRoot: z.string(),
+	artifactPaths: z.record(CliArtifactPathSchema),
+	isComplete: z.boolean(),
+	applyRequires: z.array(z.string()),
+	nextSteps: z.array(z.string()),
+	actionContext: CliActionContextSchema,
+	artifacts: z.array(CliStatusArtifactSchema),
+	root: CliRootSchema
+}).passthrough();
+/** Typed success or diagnostic failure result of the CLI Status JSON command. */
+const CliWorkflowStatusSchema = z.union([CliWorkflowStatusSuccessSchema, CliDiagnosticFailureSchema]);
+const CliInstructionDependencySchema = z.object({
+	id: z.string(),
+	done: z.boolean(),
+	path: z.string(),
+	description: z.string()
+}).passthrough();
+/** Complete successful artifact Instructions payload. */
+const CliArtifactInstructionsSuccessSchema = z.object({
+	changeName: z.string(),
+	artifactId: z.string(),
+	schemaName: z.string(),
+	changeDir: z.string(),
+	planningHome: CliPlanningHomeSchema,
+	outputPath: z.string(),
+	resolvedOutputPath: z.string(),
+	existingOutputPaths: z.array(z.string()),
+	description: z.string(),
+	instruction: z.string().optional(),
+	context: z.string().optional(),
+	rules: z.array(z.string()).optional(),
+	template: z.string(),
+	dependencies: z.array(CliInstructionDependencySchema),
+	unlocks: z.array(z.string()),
+	references: z.array(CliReferenceIndexEntrySchema).optional(),
+	root: CliRootSchema
+}).passthrough();
+/** Typed success or diagnostic failure result for artifact Instructions. */
+const CliArtifactInstructionsSchema = z.union([CliArtifactInstructionsSuccessSchema, CliDiagnosticFailureSchema]);
+const CliApplyTaskSchema = z.object({
+	id: z.string(),
+	description: z.string(),
+	done: z.boolean()
+}).passthrough();
+/** Complete successful Apply Instructions payload, including raw Apply progress. */
+const CliApplyInstructionsSuccessSchema = z.object({
+	changeName: z.string(),
+	changeDir: z.string(),
+	schemaName: z.string(),
+	contextFiles: z.record(z.array(z.string())),
+	progress: z.object({
+		total: z.number(),
+		complete: z.number(),
+		remaining: z.number()
+	}),
+	tasks: z.array(CliApplyTaskSchema),
+	state: z.enum([
+		"blocked",
+		"all_done",
+		"ready"
+	]),
+	missingArtifacts: z.array(z.string()).optional(),
+	instruction: z.string(),
+	references: z.array(CliReferenceIndexEntrySchema).optional(),
+	root: CliRootSchema
+}).passthrough();
+/** Typed success or diagnostic failure result of the CLI Apply Instructions command. */
+const CliApplyInstructionsSchema = z.union([CliApplyInstructionsSuccessSchema, CliDiagnosticFailureSchema]);
+const CliValidationIssueSchema = z.object({
+	level: z.enum([
+		"ERROR",
+		"WARNING",
+		"INFO"
+	]),
+	path: z.string(),
+	message: z.string(),
+	line: z.number().optional(),
+	column: z.number().optional()
+}).passthrough();
+const CliValidationTotalsSchema = z.object({
+	items: z.number(),
+	passed: z.number(),
+	failed: z.number()
+}).passthrough();
+/** Typed strict or non-strict Validate result, including upstream failure diagnostics. */
+const CliValidateSchema = z.union([z.object({
+	items: z.array(z.object({
+		id: z.string(),
+		type: z.enum(["change", "spec"]),
+		valid: z.boolean(),
+		issues: z.array(CliValidationIssueSchema),
+		durationMs: z.number()
+	}).passthrough()),
+	summary: z.object({
+		totals: CliValidationTotalsSchema,
+		byType: z.record(CliValidationTotalsSchema)
+	}).passthrough(),
+	version: z.string(),
+	root: CliRootSchema
+}).passthrough(), CliDiagnosticFailureSchema]);
+const CliArchiveTotalsSchema = z.object({
+	added: z.number(),
+	modified: z.number(),
+	removed: z.number(),
+	renamed: z.number()
+}).passthrough();
+/** Typed Archive result without inferred retry or readiness semantics. */
+const CliArchiveSchema = z.object({
+	archive: z.object({
+		change: z.string(),
+		archivedAs: z.string(),
+		path: z.string(),
+		specsUpdated: z.boolean(),
+		totals: CliArchiveTotalsSchema.optional()
+	}).passthrough().nullable(),
+	root: CliRootSchema.optional(),
+	status: z.array(CliDiagnosticSchema).optional()
+}).passthrough();
+
+//#endregion
+//#region src/cli-contracts/executor.ts
+/** Typed OpenSpec 1.6 command facade over the raw process executor. */
+var OpenSpecCliContractExecutor = class {
+	constructor(executeCli) {
+		this.executeCli = executeCli;
+	}
+	async execute(args, schema) {
+		return parseCliCommandResult(await this.executeCli(args), schema);
+	}
+	withRoot(args, selector = {}) {
+		if (selector.store !== void 0) args.push("--store", selector.store);
+		return args;
+	}
+	withWorkflowOptions(args, options = {}) {
+		if (options.schema !== void 0) args.push("--schema", options.schema);
+		return this.withRoot(args, options);
+	}
+	/** List changes in the CLI-selected planning root. */
+	async listChanges(selector = {}) {
+		return this.execute(this.withRoot(["list", "--json"], selector), CliChangeListSchema);
+	}
+	/** List owned or explicitly selected Store Specs through the official CLI. */
+	async listSpecs(selector = {}) {
+		return this.execute(this.withRoot([
+			"list",
+			"--specs",
+			"--json"
+		], selector), CliSpecListSchema);
+	}
+	/** Read one owned or explicitly selected Store Spec through the official CLI. */
+	async showSpec(specId, selector = {}) {
+		return this.execute(this.withRoot([
+			"show",
+			specId,
+			"--type",
+			"spec",
+			"--json"
+		], selector), CliShowSpecSchema);
+	}
+	/** List workflow schemas through the CLI JSON contract. */
+	async schemas() {
+		return this.execute(["schemas", "--json"], CliSchemasSchema);
+	}
+	/** Resolve one workflow schema through the CLI JSON contract. */
+	async schemaWhich(name) {
+		return this.execute([
+			"schema",
+			"which",
+			name,
+			"--json"
+		], CliSchemaWhichSchema);
+	}
+	/** List the resolved template index through the CLI JSON contract. */
+	async templates(schema) {
+		const args = ["templates", "--json"];
+		if (schema !== void 0) args.push("--schema", schema);
+		return this.execute(args, CliTemplatesSchema);
+	}
+	/** Read complete workflow Status evidence for one change. */
+	async workflowStatus(changeId, options = {}) {
+		return this.execute(this.withWorkflowOptions([
+			"status",
+			"--change",
+			changeId,
+			"--json"
+		], options), CliWorkflowStatusSchema);
+	}
+	/** Read complete Instructions evidence for one workflow artifact. */
+	async artifactInstructions(changeId, artifactId, options = {}) {
+		return this.execute(this.withWorkflowOptions([
+			"instructions",
+			artifactId,
+			"--change",
+			changeId,
+			"--json"
+		], options), CliArtifactInstructionsSchema);
+	}
+	/** Read complete Apply Instructions evidence for one change. */
+	async applyInstructions(changeId, options = {}) {
+		return this.execute(this.withWorkflowOptions([
+			"instructions",
+			"apply",
+			"--change",
+			changeId,
+			"--json"
+		], options), CliApplyInstructionsSchema);
+	}
+	/** Inspect selected-root, Store, and Reference health through CLI Doctor. */
+	async doctorRoot(selector = {}) {
+		return this.execute(this.withRoot(["doctor", "--json"], selector), CliDoctorSchema);
+	}
+	/** Read the selected root and its direct Reference relationships. */
+	async context(selector = {}) {
+		return this.execute(this.withRoot(["context", "--json"], selector), CliContextSchema);
+	}
+	/** List Stores registered in the effective OpenSpec runtime environment. */
+	async listStores() {
+		return this.execute([
+			"store",
+			"list",
+			"--json"
+		], CliStoreListSchema);
+	}
+	/** Inspect all Stores or one explicitly present Store id. */
+	async doctorStores(id) {
+		const args = ["store", "doctor"];
+		if (id !== void 0) args.push(id);
+		args.push("--json");
+		return this.execute(args, CliStoreDoctorSchema);
+	}
+	/** Create and register a Store through the official CLI. */
+	async setupStore(id, options) {
+		const args = [
+			"store",
+			"setup",
+			id,
+			"--path",
+			options.path
+		];
+		if (options.initGit === true) args.push("--init-git");
+		if (options.initGit === false) args.push("--no-init-git");
+		if (options.remote !== void 0) args.push("--remote", options.remote);
+		args.push("--json");
+		return this.execute(args, CliStoreMutationSchema);
+	}
+	/** Register an existing Store root through the official CLI. */
+	async registerStore(path, options = {}) {
+		const args = [
+			"store",
+			"register",
+			path
+		];
+		if (options.id !== void 0) args.push("--id", options.id);
+		if (options.confirmIdentity) args.push("--yes");
+		args.push("--json");
+		return this.execute(args, CliStoreMutationSchema);
+	}
+	/** Remove one Store registry entry without deleting its checkout. */
+	async unregisterStore(id) {
+		return this.execute([
+			"store",
+			"unregister",
+			id,
+			"--json"
+		], CliStoreCleanupSchema);
+	}
+	/** Remove one Store through the official CLI destructive boundary. */
+	async removeStore(id, options = {}) {
+		const args = [
+			"store",
+			"remove",
+			id
+		];
+		if (options.confirmDelete) args.push("--yes");
+		args.push("--json");
+		return this.execute(args, CliStoreCleanupSchema);
+	}
+	/** Validate an item or scope without inferring retries or readiness. */
+	async validate(options) {
+		const args = ["validate"];
+		if (options.target.kind === "item") {
+			args.push(options.target.id);
+			if (options.target.type) args.push("--type", options.target.type);
+		} else args.push(`--${options.target.scope}`);
+		if (options.strict) args.push("--strict");
+		args.push("--json");
+		return this.execute(this.withRoot(args, options), CliValidateSchema);
+	}
+	/** Archive one change without implicit validation bypass or retry. */
+	async archive(changeId, options = {}) {
+		const args = [
+			"archive",
+			changeId,
+			"--json",
+			"--yes"
+		];
+		if (options.skipSpecs) args.push("--skip-specs");
+		if (options.noValidate) args.push("--no-validate");
+		return this.execute(this.withRoot(args, options), CliArchiveSchema);
+	}
+};
+
+//#endregion
+//#region src/spec-catalog.ts
+/**
+* Orthogonal intents (updated 2026-07-27 Asia/Shanghai):
+* 1. Define collision-safe owned and referenced Spec identity.
+* 2. Build one source-aware live/static Spec Catalog with CLI-owned membership and source-exact provenance.
+* 3. Define source-distinct Spec detail projections without inventing upstream or snapshot fields.
+* 4. Publish browser-safe Catalog/document runtime schemas for typed Projection Pull.
+*
+* Original request (2026-07-15): "Live and static modes share one source-aware Spec Catalog."
+* Original request (2026-07-26): "展开全面的接口升级和内核升级和测试升级。"
+*/
+/** Runtime validator for one writable owned Spec identity. */
+const OwnedSpecIdentitySchema = z.object({
+	kind: z.literal("owned"),
+	specId: z.string().min(1)
+});
+/** Runtime validator for one Store-qualified read-only Spec identity. */
+const ReferencedSpecIdentitySchema = z.object({
+	kind: z.literal("referenced"),
+	storeId: z.string().min(1),
+	specId: z.string().min(1)
+});
+/** Runtime validator for the complete compound Spec identity union. */
+const SpecIdentitySchema = z.discriminatedUnion("kind", [OwnedSpecIdentitySchema, ReferencedSpecIdentitySchema]);
+const SpecCommandEvidenceSchema = CliProjectionCommandEvidenceSchema;
+const OwnedSpecCatalogEntrySchema = z.object({
+	identity: OwnedSpecIdentitySchema,
+	source: z.literal("owned"),
+	readOnly: z.literal(false),
+	name: z.string(),
+	summary: z.null(),
+	requirementCount: z.number(),
+	updatedAt: z.number()
+});
+const SpecCatalogOwnedProjectionSchema = z.union([z.object({
+	provenance: z.literal("live"),
+	root: CliRootSchema,
+	evidence: SpecCommandEvidenceSchema
+}), z.discriminatedUnion("state", [z.object({
+	provenance: z.literal("static"),
+	state: z.literal("available"),
+	snapshot: z.object({ specCount: z.number().int().nonnegative() })
+}), z.object({
+	provenance: z.literal("static"),
+	state: z.literal("unavailable")
+})])]);
+const ReferencedSpecCatalogEntrySchema = z.object({
+	identity: ReferencedSpecIdentitySchema,
+	source: z.literal("referenced"),
+	readOnly: z.literal(true),
+	name: z.string(),
+	summary: z.null(),
+	requirementCount: z.number(),
+	updatedAt: z.literal(0)
+});
+const LiveSpecCatalogReferenceSourceSchema = z.object({
+	storeId: z.string(),
+	provenance: z.literal("live"),
+	state: z.enum(["ready", "error"]),
+	diagnostics: z.array(CliDiagnosticSchema),
+	evidence: SpecCommandEvidenceSchema
+});
+const StaticSpecCatalogReferenceSourceSchema = z.object({
+	storeId: z.string(),
+	provenance: z.literal("static"),
+	state: z.enum(["ready", "error"]),
+	snapshot: z.object({
+		policy: z.literal("include"),
+		specCount: z.number()
+	})
+});
+const SpecCatalogReferenceProjectionSchema = z.union([z.object({ provenance: z.literal("live") }), z.discriminatedUnion("policy", [
+	z.object({
+		provenance: z.literal("static"),
+		policy: z.literal("include")
+	}),
+	z.object({
+		provenance: z.literal("static"),
+		policy: z.literal("omit"),
+		referenceSourceCount: z.number()
+	}),
+	z.object({
+		provenance: z.literal("static"),
+		policy: z.literal("none")
+	}),
+	z.object({
+		provenance: z.literal("static"),
+		policy: z.literal("unavailable")
+	})
+])]);
+/** Runtime schema for the complete source-aware Spec Catalog. */
+const SpecCatalogSchema = z.object({
+	entries: z.array(z.union([OwnedSpecCatalogEntrySchema, ReferencedSpecCatalogEntrySchema])),
+	ownedProjection: SpecCatalogOwnedProjectionSchema,
+	referenceSources: z.array(z.union([LiveSpecCatalogReferenceSourceSchema, StaticSpecCatalogReferenceSourceSchema])),
+	referenceProjection: SpecCatalogReferenceProjectionSchema,
+	observedAt: z.number()
+});
+/** Map a published snapshot count without implying that the browser executed OpenSpec CLI. */
+function createStaticSpecCatalogOwnedProjection(specCount) {
+	return specCount === void 0 ? {
+		provenance: "static",
+		state: "unavailable"
+	} : {
+		provenance: "static",
+		state: "available",
+		snapshot: { specCount }
+	};
+}
+/** Map published Reference source facts without implying a CLI execution occurred. */
+function createStaticSpecCatalogReferenceSource(input) {
+	return {
+		storeId: input.storeId,
+		provenance: "static",
+		state: input.state,
+		snapshot: {
+			policy: "include",
+			specCount: input.specCount
+		}
+	};
+}
+/** Map published static policy without converting omitted or unavailable facts into empty live inventory. */
+function createStaticSpecCatalogReferenceProjection(policy) {
+	return match(policy).with(void 0, () => ({
+		provenance: "static",
+		policy: "unavailable"
+	})).with({ kind: "include" }, () => ({
+		provenance: "static",
+		policy: "include"
+	})).with({ kind: "omit" }, ({ referenceSourceCount }) => ({
+		provenance: "static",
+		policy: "omit",
+		referenceSourceCount
+	})).with({ kind: "none" }, () => ({
+		provenance: "static",
+		policy: "none"
+	})).exhaustive();
+}
+const OwnedSpecDocumentProjectionSchema = z.object({
+	identity: OwnedSpecIdentitySchema,
+	source: z.literal("owned"),
+	readOnly: z.literal(false),
+	state: z.enum(["ready", "not-found"]),
+	spec: SpecSchema.nullable(),
+	rawMarkdown: z.string().nullable(),
+	upstream: z.null(),
+	evidence: z.null()
+});
+const LiveReferencedSpecDocumentProjectionSchema = z.object({
+	identity: ReferencedSpecIdentitySchema,
+	source: z.literal("referenced"),
+	readOnly: z.literal(true),
+	state: z.enum(["ready", "error"]),
+	spec: z.null(),
+	rawMarkdown: z.null(),
+	upstream: CliShowSpecDocumentSchema.nullable(),
+	provenance: z.object({ kind: z.literal("live") }),
+	evidence: SpecCommandEvidenceSchema
+});
+const StaticReferencedSpecDocumentProjectionSchema = z.object({
+	identity: ReferencedSpecIdentitySchema,
+	source: z.literal("referenced"),
+	readOnly: z.literal(true),
+	state: z.enum(["ready", "error"]),
+	spec: SpecSchema.nullable(),
+	rawMarkdown: z.string().nullable(),
+	upstream: CliShowSpecDocumentSchema.nullable(),
+	provenance: z.discriminatedUnion("state", [
+		z.object({
+			kind: z.literal("static"),
+			state: z.enum(["included", "missing"]),
+			policy: z.enum(["include", "unrecorded"]),
+			source: StaticSpecCatalogReferenceSourceSchema.nullable()
+		}),
+		z.object({
+			kind: z.literal("static"),
+			state: z.literal("omitted"),
+			policy: z.literal("omit"),
+			referenceSourceCount: z.number()
+		}),
+		z.object({
+			kind: z.literal("static"),
+			state: z.literal("none"),
+			policy: z.literal("none")
+		}),
+		z.object({
+			kind: z.literal("static"),
+			state: z.literal("snapshot-unavailable"),
+			policy: z.literal("absent")
+		})
+	]),
+	evidence: z.null()
+});
+/** Runtime schema for one source-aware owned or referenced Spec document projection. */
+const SpecDocumentProjectionSchema = z.union([
+	OwnedSpecDocumentProjectionSchema,
+	LiveReferencedSpecDocumentProjectionSchema,
+	StaticReferencedSpecDocumentProjectionSchema
+]);
+/** Build a collision-safe cache/search key for a compound Spec identity. */
+function specIdentityKey(identity) {
+	const specId = encodeURIComponent(identity.specId);
+	return identity.kind === "owned" ? `owned:${specId}` : `referenced:${encodeURIComponent(identity.storeId)}:${specId}`;
+}
+/** Build the canonical live/static route for a compound Spec identity. */
+function specRoutePath(identity) {
+	const specId = encodeURIComponent(identity.specId);
+	return identity.kind === "owned" ? `/specs/owned/${specId}` : `/specs/referenced/${encodeURIComponent(identity.storeId)}/${specId}`;
+}
+/** Recover compound Spec identity from canonical route parameters. */
+function specIdentityFromRoute(params) {
+	return params.storeId === void 0 ? {
+		kind: "owned",
+		specId: params.specId
+	} : {
+		kind: "referenced",
+		storeId: params.storeId,
+		specId: params.specId
+	};
+}
+/** Merge already projected owned and referenced entries without bare-id deduplication. */
+function mergeSpecCatalog(owned, referenced, ownedProjection, referenceSources, observedAt, referenceProjection = { provenance: "live" }) {
+	return {
+		entries: [...owned, ...referenced],
+		ownedProjection,
+		referenceSources: [...referenceSources],
+		referenceProjection,
+		observedAt
+	};
+}
+/** Project CLI-owned Spec membership and explicit per-Store Spec lists into one Catalog. */
+function buildSpecCatalog(input) {
+	return mergeSpecCatalog(input.owned.map((spec) => ({
+		identity: {
+			kind: "owned",
+			specId: spec.id
+		},
+		source: "owned",
+		readOnly: false,
+		name: spec.id,
+		summary: null,
+		requirementCount: spec.requirementCount,
+		updatedAt: 0
+	})), input.referenced.flatMap((source) => source.specs.map((spec) => ({
+		identity: {
+			kind: "referenced",
+			storeId: source.storeId,
+			specId: spec.id
+		},
+		source: "referenced",
+		readOnly: true,
+		name: spec.id,
+		summary: null,
+		requirementCount: spec.requirementCount,
+		updatedAt: 0
+	}))), input.ownedProjection, input.referenceSources, input.observedAt);
+}
+/** Look up only the exact compound identity in a Catalog. */
+function getSpecCatalogEntry(catalog, identity) {
+	const key = specIdentityKey(identity);
+	return catalog.entries.find((entry) => specIdentityKey(entry.identity) === key) ?? null;
+}
+/** Narrow a compound Spec identity to its Store-qualified read-only form. */
+function isReferencedSpecIdentity(identity) {
+	return identity.kind === "referenced";
+}
+
+//#endregion
+export { CliSchemasSchema as A, CliStoreCleanupSchema as B, CliArtifactInstructionsSuccessSchema as C, CliSchemaInfoSchema as D, CliPlanningHomeSchema as E, CliValidateSchema as F, CliStoreSchema as G, CliStoreDoctorSchema as H, CliWorkflowStatusSchema as I, parseCliCommandResult as K, CliWorkflowStatusSuccessSchema as L, CliShowSpecSchema as M, CliSpecListSchema as N, CliSchemaResolutionSchema as O, CliTemplateEntrySchema as P, CliContextSchema as R, CliArtifactInstructionsSchema as S, CliChangeListSchema as T, CliStoreListSchema as U, CliStoreDoctorEntrySchema as V, CliStoreMutationSchema as W, OpenSpecCliContractExecutor as _, SpecDocumentProjectionSchema as a, CliApplyInstructionsSuccessSchema as b, createStaticSpecCatalogOwnedProjection as c, getSpecCatalogEntry as d, isReferencedSpecIdentity as f, specRoutePath as g, specIdentityKey as h, SpecCommandEvidenceSchema as i, CliShowSpecDocumentSchema as j, CliSchemaShadowSchema as k, createStaticSpecCatalogReferenceProjection as l, specIdentityFromRoute as m, ReferencedSpecIdentitySchema as n, SpecIdentitySchema as o, mergeSpecCatalog as p, SpecCatalogSchema as r, buildSpecCatalog as s, OwnedSpecIdentitySchema as t, createStaticSpecCatalogReferenceSource as u, CliActionContextSchema as v, CliArtifactPathSchema as w, CliArchiveSchema as x, CliApplyInstructionsSchema as y, CliDoctorSchema as z };