@openspecui/core 3.6.1 → 3.7.1

package/dist/openspec-projection-DgnEag63.d.mts

@@ -0,0 +1,52 @@
+import { g as Spec } from "./schemas-DZwT0am4.mjs";
+import { d as MarkdownReadingPlugin, l as MarkdownReadingDocument } from "./markdown-reading-BC6uFgx0.mjs";
+import { n as OpenSpecAnnotation, t as AnnotatedOpenSpecDocument } from "./openspec-annotations-DKP1Uuho.mjs";
+
+//#region src/openspec-projection.d.ts
+declare const OPEN_SPEC_SPEC_PROJECTION_ID = "openspec.projection.spec.v2";
+declare const OPEN_SPEC_READING_SECTIONS_PROJECTION_ID = "openspec.projection.reading-sections.v2";
+type SpecSectionKind = 'overview' | 'requirements' | 'other';
+interface OpenSpecProjectionOptions {
+  specId: string;
+}
+interface OpenSpecHeadingSection {
+  id: string;
+  title: string;
+  kind: SpecSectionKind;
+  factId: string;
+  start: number;
+  end: number;
+}
+interface OpenSpecRequirementBlock {
+  id: string;
+  title: string;
+  factId: string;
+  start: number;
+  end: number;
+  scenarios: OpenSpecScenarioBlock[];
+}
+interface OpenSpecScenarioBlock {
+  title: string;
+  factId: string;
+  start: number;
+  end: number;
+}
+interface OpenSpecReadingSectionsProjection {
+  sections: OpenSpecHeadingSection[];
+  requirements: OpenSpecRequirementBlock[];
+}
+interface ProjectedOpenSpecDocument extends MarkdownReadingDocument {
+  annotations: OpenSpecAnnotation[];
+  projections: MarkdownReadingDocument['projections'] & {
+    [OPEN_SPEC_SPEC_PROJECTION_ID]?: Spec;
+    [OPEN_SPEC_READING_SECTIONS_PROJECTION_ID]?: OpenSpecReadingSectionsProjection;
+  };
+}
+declare function createOpenSpecReadingPlugin(options: OpenSpecProjectionOptions): MarkdownReadingPlugin;
+declare function parseOpenSpecMarkdownToSpec(specId: string, content: string): Spec;
+declare function projectOpenSpecMarkdown(sourceMarkdown: string, options: OpenSpecProjectionOptions, plugins?: readonly MarkdownReadingPlugin[]): ProjectedOpenSpecDocument;
+declare function projectAnnotatedOpenSpecToSpec(specId: string, document: AnnotatedOpenSpecDocument): Spec;
+declare function getOpenSpecReadingSections(document: Pick<MarkdownReadingDocument, 'facts' | 'annotations' | 'sourceMarkdown'>): OpenSpecReadingSectionsProjection;
+declare function getOpenSpecProjectionAnnotation(annotations: readonly OpenSpecAnnotation[], factId: string, kind: OpenSpecAnnotation['kind']): OpenSpecAnnotation | undefined;
+//#endregion
+export { OpenSpecReadingSectionsProjection as a, ProjectedOpenSpecDocument as c, getOpenSpecReadingSections as d, parseOpenSpecMarkdownToSpec as f, OpenSpecProjectionOptions as i, createOpenSpecReadingPlugin as l, projectOpenSpecMarkdown as m, OPEN_SPEC_SPEC_PROJECTION_ID as n, OpenSpecRequirementBlock as o, projectAnnotatedOpenSpecToSpec as p, OpenSpecHeadingSection as r, OpenSpecScenarioBlock as s, OPEN_SPEC_READING_SECTIONS_PROJECTION_ID as t, getOpenSpecProjectionAnnotation as u };

package/dist/openspec-projection.d.mts

@@ -1,5 +1,6 @@
-import { a as OpenSpecReadingSectionsProjection, c as ProjectedOpenSpecDocument, d as getOpenSpecReadingSections, f as parseOpenSpecMarkdownToSpec, i as OpenSpecProjectionOptions, l as createOpenSpecReadingPlugin, m as projectOpenSpecMarkdown, n as OPEN_SPEC_SPEC_PROJECTION_ID, o as OpenSpecRequirementBlock, p as projectAnnotatedOpenSpecToSpec, r as OpenSpecHeadingSection, s as OpenSpecScenarioBlock, t as OPEN_SPEC_READING_SECTIONS_PROJECTION_ID, u as getOpenSpecProjectionAnnotation } from "./openspec-projection-DmB448No.mjs";
-import "./markdown-facts-f3kXnqXb.mjs";
-import "./markdown-reading-D36W693c.mjs";
-import "./openspec-annotations-CJmYcfAu.mjs";
+import "./schemas-DZwT0am4.mjs";
+import "./markdown-facts-DxElzSsp.mjs";
+import "./markdown-reading-BC6uFgx0.mjs";
+import "./openspec-annotations-DKP1Uuho.mjs";
+import { a as OpenSpecReadingSectionsProjection, c as ProjectedOpenSpecDocument, d as getOpenSpecReadingSections, f as parseOpenSpecMarkdownToSpec, i as OpenSpecProjectionOptions, l as createOpenSpecReadingPlugin, m as projectOpenSpecMarkdown, n as OPEN_SPEC_SPEC_PROJECTION_ID, o as OpenSpecRequirementBlock, p as projectAnnotatedOpenSpecToSpec, r as OpenSpecHeadingSection, s as OpenSpecScenarioBlock, t as OPEN_SPEC_READING_SECTIONS_PROJECTION_ID, u as getOpenSpecProjectionAnnotation } from "./openspec-projection-DgnEag63.mjs";
 export { OPEN_SPEC_READING_SECTIONS_PROJECTION_ID, OPEN_SPEC_SPEC_PROJECTION_ID, OpenSpecHeadingSection, OpenSpecProjectionOptions, OpenSpecReadingSectionsProjection, OpenSpecRequirementBlock, OpenSpecScenarioBlock, ProjectedOpenSpecDocument, createOpenSpecReadingPlugin, getOpenSpecProjectionAnnotation, getOpenSpecReadingSections, parseOpenSpecMarkdownToSpec, projectAnnotatedOpenSpecToSpec, projectOpenSpecMarkdown };

package/dist/openspec-projection.mjs

@@ -1,6 +1,6 @@
-import "./markdown-facts-BmSmZmpB.mjs";
-import "./markdown-reading-CrchEfoW.mjs";
-import "./openspec-annotations-BMy9nWUe.mjs";
-import { a as getOpenSpecReadingSections, c as projectOpenSpecMarkdown, i as getOpenSpecProjectionAnnotation, n as OPEN_SPEC_SPEC_PROJECTION_ID, o as parseOpenSpecMarkdownToSpec, r as createOpenSpecReadingPlugin, s as projectAnnotatedOpenSpecToSpec, t as OPEN_SPEC_READING_SECTIONS_PROJECTION_ID } from "./openspec-projection-DWqBxedv.mjs";
+import "./markdown-facts-BFqXdPfN.mjs";
+import "./markdown-reading-CsL1q84q.mjs";
+import "./openspec-annotations-D_xQqQOB.mjs";
+import { a as getOpenSpecReadingSections, c as projectOpenSpecMarkdown, i as getOpenSpecProjectionAnnotation, n as OPEN_SPEC_SPEC_PROJECTION_ID, o as parseOpenSpecMarkdownToSpec, r as createOpenSpecReadingPlugin, s as projectAnnotatedOpenSpecToSpec, t as OPEN_SPEC_READING_SECTIONS_PROJECTION_ID } from "./openspec-projection-DLGD1JFD.mjs";
 
 export { OPEN_SPEC_READING_SECTIONS_PROJECTION_ID, OPEN_SPEC_SPEC_PROJECTION_ID, createOpenSpecReadingPlugin, getOpenSpecProjectionAnnotation, getOpenSpecReadingSections, parseOpenSpecMarkdownToSpec, projectAnnotatedOpenSpecToSpec, projectOpenSpecMarkdown };

package/dist/opsx-display-path.d.mts

@@ -1,2 +1,2 @@
-import { n as toOpsxDisplayPath, t as VIRTUAL_PROJECT_DIRNAME } from "./opsx-display-path-CkV9sq_j.mjs";
+import { n as toOpsxDisplayPath, t as VIRTUAL_PROJECT_DIRNAME } from "./opsx-display-path-BKUYCqwP.mjs";
 export { VIRTUAL_PROJECT_DIRNAME, toOpsxDisplayPath };

package/dist/opsx-display-path.mjs

@@ -1,3 +1,3 @@
-import { n as toOpsxDisplayPath, t as VIRTUAL_PROJECT_DIRNAME } from "./opsx-display-path-D4KLYRXQ.mjs";
+import { n as toOpsxDisplayPath, t as VIRTUAL_PROJECT_DIRNAME } from "./opsx-display-path-BHEPZsJx.mjs";
 
 export { VIRTUAL_PROJECT_DIRNAME, toOpsxDisplayPath };

package/dist/opsx-entity-B_Od4N3r.mjs

@@ -0,0 +1,144 @@
+import { parse } from "yaml";
+
+//#region src/opsx-entity.ts
+function getOpsxEntityRootRelativePath(stage, id) {
+	return stage === "change" ? `openspec/changes/${id}` : `openspec/changes/archive/${id}`;
+}
+function getOpsxEntityMetadataPath(stage, id) {
+	return `${getOpsxEntityRootRelativePath(stage, id)}/.openspec.yaml`;
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeOpsxEntityPath(path) {
+	return path.replace(/\\/g, "/").replace(/^\.?\//, "").replace(/^\/+/, "");
+}
+function isOpsxGlobPattern(path) {
+	return path.includes("*") || path.includes("?") || path.includes("[");
+}
+function escapeRegexChar(char) {
+	return /[\\^$.*+?()[\]{}|]/.test(char) ? `\\${char}` : char;
+}
+function opsxGlobToRegex(pattern) {
+	const normalized = normalizeOpsxEntityPath(pattern);
+	let source = "^";
+	for (let index = 0; index < normalized.length; index += 1) {
+		const char = normalized[index];
+		if (char === "*") {
+			if (normalized[index + 1] === "*") {
+				index += 1;
+				if (normalized[index + 1] === "/") {
+					index += 1;
+					source += "(?:.*/)?";
+				} else source += ".*";
+			} else source += "[^/]*";
+			continue;
+		}
+		if (char === "?") {
+			source += "[^/]";
+			continue;
+		}
+		if (char === "[") {
+			const closeIndex = normalized.indexOf("]", index + 1);
+			if (closeIndex > index + 1) {
+				source += normalized.slice(index, closeIndex + 1);
+				index = closeIndex;
+				continue;
+			}
+		}
+		source += escapeRegexChar(char);
+	}
+	source += "$";
+	return new RegExp(source);
+}
+function opsxPathMatchesPattern(path, pattern) {
+	const normalizedPath = normalizeOpsxEntityPath(path);
+	const normalizedPattern = normalizeOpsxEntityPath(pattern);
+	if (!isOpsxGlobPattern(normalizedPattern)) return normalizedPath === normalizedPattern;
+	return opsxGlobToRegex(normalizedPattern).test(normalizedPath);
+}
+function parseOpsxEntityMetadata(content) {
+	if (!content) return { diagnostics: [] };
+	try {
+		const parsed = parse(content);
+		if (!isRecord(parsed)) return { diagnostics: [{
+			level: "warning",
+			path: ".openspec.yaml",
+			message: "Entity metadata is not a YAML object."
+		}] };
+		const schema = parsed.schema;
+		if (typeof schema === "string" && schema.trim().length > 0) return {
+			schemaName: schema.trim(),
+			diagnostics: []
+		};
+		return { diagnostics: [{
+			level: "warning",
+			path: ".openspec.yaml",
+			message: "Entity metadata does not declare a usable schema name."
+		}] };
+	} catch (error) {
+		return { diagnostics: [{
+			level: "warning",
+			path: ".openspec.yaml",
+			message: `Entity metadata could not be parsed: ${error instanceof Error ? error.message : String(error)}`
+		}] };
+	}
+}
+function getMetadataContent(files) {
+	const metadata = files.find((file) => file.type === "file" && file.path === ".openspec.yaml");
+	return metadata?.type === "file" ? metadata.content ?? null : null;
+}
+function getSchemaDetail(schemaName, schemas, schemaDiagnostics, diagnostics) {
+	if (!schemaName) return null;
+	const schemaDiagnosticItems = schemaDiagnostics?.[schemaName];
+	if (schemaDiagnosticItems) diagnostics.push(...schemaDiagnosticItems);
+	if (!schemas) return null;
+	const detail = schemas[schemaName];
+	if (detail) return detail;
+	diagnostics.push({
+		level: "warning",
+		path: ".openspec.yaml",
+		message: `Schema "${schemaName}" is not available; showing entity files without schema artifact binding.`
+	});
+	return null;
+}
+function getArtifactFiles(files, outputPath) {
+	return files.filter((file) => {
+		if (file.type !== "file") return false;
+		return opsxPathMatchesPattern(file.path, outputPath);
+	});
+}
+function buildOpsxEntityDetail(input) {
+	const diagnostics = [];
+	const metadata = parseOpsxEntityMetadata(getMetadataContent(input.files));
+	diagnostics.push(...metadata.diagnostics);
+	const schemaDetail = getSchemaDetail(metadata.schemaName, input.schemas, input.schemaDiagnostics, diagnostics);
+	const artifactPathSet = /* @__PURE__ */ new Set();
+	const artifacts = schemaDetail?.artifacts.map((artifact) => {
+		const files = getArtifactFiles(input.files, artifact.outputPath);
+		for (const file of files) artifactPathSet.add(file.path);
+		return {
+			id: artifact.id,
+			outputPath: artifact.outputPath,
+			description: artifact.description,
+			files
+		};
+	}) ?? [];
+	const ungroupedFiles = input.files.filter((file) => {
+		if (file.type !== "file") return true;
+		return !artifactPathSet.has(file.path);
+	});
+	return {
+		stage: input.stage,
+		id: input.id,
+		exists: true,
+		schemaName: metadata.schemaName,
+		files: input.files,
+		artifacts,
+		ungroupedFiles,
+		diagnostics
+	};
+}
+
+//#endregion
+export { normalizeOpsxEntityPath as a, parseOpsxEntityMetadata as c, isOpsxGlobPattern as i, getOpsxEntityMetadataPath as n, opsxGlobToRegex as o, getOpsxEntityRootRelativePath as r, opsxPathMatchesPattern as s, buildOpsxEntityDetail as t };

package/dist/opsx-entity-BhvuPO8B.d.mts

@@ -0,0 +1,453 @@
+import { n as ChangeFile } from "./schemas-DZwT0am4.mjs";
+import { z } from "zod";
+
+//#region src/opsx-types.d.ts
+/** Check if an outputPath contains glob pattern characters */
+declare function isGlobPattern(pattern: string): boolean;
+declare const ArtifactStatusSchema: z.ZodObject<{
+  id: z.ZodString;
+  outputPath: z.ZodString;
+  status: z.ZodEnum<["done", "ready", "blocked"]>;
+  missingDeps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+  relativePath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+  status: "done" | "ready" | "blocked";
+  id: string;
+  outputPath: string;
+  missingDeps?: string[] | undefined;
+  relativePath?: string | undefined;
+}, {
+  status: "done" | "ready" | "blocked";
+  id: string;
+  outputPath: string;
+  missingDeps?: string[] | undefined;
+  relativePath?: string | undefined;
+}>;
+type ArtifactStatus = z.infer<typeof ArtifactStatusSchema>;
+declare const ChangeStatusSchema: z.ZodObject<{
+  changeName: z.ZodString;
+  schemaName: z.ZodString;
+  isComplete: z.ZodBoolean;
+  applyRequires: z.ZodArray<z.ZodString, "many">;
+  artifacts: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    outputPath: z.ZodString;
+    status: z.ZodEnum<["done", "ready", "blocked"]>;
+    missingDeps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    relativePath: z.ZodOptional<z.ZodString>;
+  }, "strip", z.ZodTypeAny, {
+    status: "done" | "ready" | "blocked";
+    id: string;
+    outputPath: string;
+    missingDeps?: string[] | undefined;
+    relativePath?: string | undefined;
+  }, {
+    status: "done" | "ready" | "blocked";
+    id: string;
+    outputPath: string;
+    missingDeps?: string[] | undefined;
+    relativePath?: string | undefined;
+  }>, "many">;
+}, "strip", z.ZodTypeAny, {
+  changeName: string;
+  schemaName: string;
+  isComplete: boolean;
+  applyRequires: string[];
+  artifacts: {
+    status: "done" | "ready" | "blocked";
+    id: string;
+    outputPath: string;
+    missingDeps?: string[] | undefined;
+    relativePath?: string | undefined;
+  }[];
+}, {
+  changeName: string;
+  schemaName: string;
+  isComplete: boolean;
+  applyRequires: string[];
+  artifacts: {
+    status: "done" | "ready" | "blocked";
+    id: string;
+    outputPath: string;
+    missingDeps?: string[] | undefined;
+    relativePath?: string | undefined;
+  }[];
+}>;
+type ChangeStatus = z.infer<typeof ChangeStatusSchema>;
+declare const DependencyInfoSchema: z.ZodObject<{
+  id: z.ZodString;
+  done: z.ZodBoolean;
+  path: z.ZodString;
+  description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+  path: string;
+  id: string;
+  description: string;
+  done: boolean;
+}, {
+  path: string;
+  id: string;
+  description: string;
+  done: boolean;
+}>;
+type DependencyInfo = z.infer<typeof DependencyInfoSchema>;
+declare const ApplyTaskSchema: z.ZodObject<{
+  id: z.ZodString;
+  description: z.ZodString;
+  done: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+  id: string;
+  description: string;
+  done: boolean;
+}, {
+  id: string;
+  description: string;
+  done: boolean;
+}>;
+type ApplyTask = z.infer<typeof ApplyTaskSchema>;
+declare const ApplyInstructionsContextFilesSchema: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, string[], string | string[]>>;
+declare const ApplyInstructionsSchema: z.ZodObject<{
+  changeName: z.ZodString;
+  changeDir: z.ZodString;
+  schemaName: z.ZodString;
+  contextFiles: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, string[], string | string[]>>;
+  progress: z.ZodObject<{
+    total: z.ZodNumber;
+    complete: z.ZodNumber;
+    remaining: z.ZodNumber;
+  }, "strip", z.ZodTypeAny, {
+    total: number;
+    complete: number;
+    remaining: number;
+  }, {
+    total: number;
+    complete: number;
+    remaining: number;
+  }>;
+  tasks: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    done: z.ZodBoolean;
+  }, "strip", z.ZodTypeAny, {
+    id: string;
+    description: string;
+    done: boolean;
+  }, {
+    id: string;
+    description: string;
+    done: boolean;
+  }>, "many">;
+  state: z.ZodEnum<["blocked", "all_done", "ready"]>;
+  missingArtifacts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+  instruction: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+  tasks: {
+    id: string;
+    description: string;
+    done: boolean;
+  }[];
+  progress: {
+    total: number;
+    complete: number;
+    remaining: number;
+  };
+  state: "ready" | "blocked" | "all_done";
+  changeName: string;
+  schemaName: string;
+  changeDir: string;
+  contextFiles: Record<string, string[]>;
+  instruction: string;
+  missingArtifacts?: string[] | undefined;
+}, {
+  tasks: {
+    id: string;
+    description: string;
+    done: boolean;
+  }[];
+  progress: {
+    total: number;
+    complete: number;
+    remaining: number;
+  };
+  state: "ready" | "blocked" | "all_done";
+  changeName: string;
+  schemaName: string;
+  changeDir: string;
+  contextFiles: Record<string, string | string[]>;
+  instruction: string;
+  missingArtifacts?: string[] | undefined;
+}>;
+type ApplyInstructions = z.infer<typeof ApplyInstructionsSchema>;
+declare const ArtifactInstructionsSchema: z.ZodObject<{
+  changeName: z.ZodString;
+  artifactId: z.ZodString;
+  schemaName: z.ZodString;
+  changeDir: z.ZodString;
+  outputPath: z.ZodString;
+  description: z.ZodString;
+  instruction: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  context: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  rules: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+  template: z.ZodString;
+  dependencies: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    done: z.ZodBoolean;
+    path: z.ZodString;
+    description: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    path: string;
+    id: string;
+    description: string;
+    done: boolean;
+  }, {
+    path: string;
+    id: string;
+    description: string;
+    done: boolean;
+  }>, "many">;
+  unlocks: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+  description: string;
+  template: string;
+  outputPath: string;
+  changeName: string;
+  schemaName: string;
+  changeDir: string;
+  artifactId: string;
+  dependencies: {
+    path: string;
+    id: string;
+    description: string;
+    done: boolean;
+  }[];
+  unlocks: string[];
+  instruction?: string | null | undefined;
+  context?: string | null | undefined;
+  rules?: string[] | null | undefined;
+}, {
+  description: string;
+  template: string;
+  outputPath: string;
+  changeName: string;
+  schemaName: string;
+  changeDir: string;
+  artifactId: string;
+  dependencies: {
+    path: string;
+    id: string;
+    description: string;
+    done: boolean;
+  }[];
+  unlocks: string[];
+  instruction?: string | null | undefined;
+  context?: string | null | undefined;
+  rules?: string[] | null | undefined;
+}>;
+type ArtifactInstructions = z.infer<typeof ArtifactInstructionsSchema>;
+declare const SchemaInfoSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  artifacts: z.ZodArray<z.ZodString, "many">;
+  source: z.ZodEnum<["project", "user", "package"]>;
+}, "strip", z.ZodTypeAny, {
+  name: string;
+  source: "project" | "user" | "package";
+  artifacts: string[];
+  description?: string | undefined;
+}, {
+  name: string;
+  source: "project" | "user" | "package";
+  artifacts: string[];
+  description?: string | undefined;
+}>;
+type SchemaInfo = z.infer<typeof SchemaInfoSchema>;
+declare const SchemaResolutionSchema: z.ZodObject<{
+  name: z.ZodString;
+  source: z.ZodEnum<["project", "user", "package"]>;
+  path: z.ZodString;
+  displayPath: z.ZodOptional<z.ZodString>;
+  shadows: z.ZodArray<z.ZodObject<{
+    source: z.ZodEnum<["project", "user", "package"]>;
+    path: z.ZodString;
+    displayPath: z.ZodOptional<z.ZodString>;
+  }, "strip", z.ZodTypeAny, {
+    path: string;
+    source: "project" | "user" | "package";
+    displayPath?: string | undefined;
+  }, {
+    path: string;
+    source: "project" | "user" | "package";
+    displayPath?: string | undefined;
+  }>, "many">;
+}, "strip", z.ZodTypeAny, {
+  path: string;
+  name: string;
+  source: "project" | "user" | "package";
+  shadows: {
+    path: string;
+    source: "project" | "user" | "package";
+    displayPath?: string | undefined;
+  }[];
+  displayPath?: string | undefined;
+}, {
+  path: string;
+  name: string;
+  source: "project" | "user" | "package";
+  shadows: {
+    path: string;
+    source: "project" | "user" | "package";
+    displayPath?: string | undefined;
+  }[];
+  displayPath?: string | undefined;
+}>;
+type SchemaResolution = z.infer<typeof SchemaResolutionSchema>;
+declare const TemplatesSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+  path: z.ZodString;
+  displayPath: z.ZodOptional<z.ZodString>;
+  source: z.ZodEnum<["project", "user", "package"]>;
+}, "strip", z.ZodTypeAny, {
+  path: string;
+  source: "project" | "user" | "package";
+  displayPath?: string | undefined;
+}, {
+  path: string;
+  source: "project" | "user" | "package";
+  displayPath?: string | undefined;
+}>>;
+type TemplatesMap = z.infer<typeof TemplatesSchema>;
+declare const SchemaArtifactSchema: z.ZodObject<{
+  id: z.ZodString;
+  outputPath: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  template: z.ZodOptional<z.ZodString>;
+  instruction: z.ZodOptional<z.ZodString>;
+  requires: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+  id: string;
+  outputPath: string;
+  requires: string[];
+  description?: string | undefined;
+  template?: string | undefined;
+  instruction?: string | undefined;
+}, {
+  id: string;
+  outputPath: string;
+  requires: string[];
+  description?: string | undefined;
+  template?: string | undefined;
+  instruction?: string | undefined;
+}>;
+type SchemaArtifact = z.infer<typeof SchemaArtifactSchema>;
+declare const SchemaDetailSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  version: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+  artifacts: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    outputPath: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    template: z.ZodOptional<z.ZodString>;
+    instruction: z.ZodOptional<z.ZodString>;
+    requires: z.ZodArray<z.ZodString, "many">;
+  }, "strip", z.ZodTypeAny, {
+    id: string;
+    outputPath: string;
+    requires: string[];
+    description?: string | undefined;
+    template?: string | undefined;
+    instruction?: string | undefined;
+  }, {
+    id: string;
+    outputPath: string;
+    requires: string[];
+    description?: string | undefined;
+    template?: string | undefined;
+    instruction?: string | undefined;
+  }>, "many">;
+  applyRequires: z.ZodArray<z.ZodString, "many">;
+  applyTracks: z.ZodOptional<z.ZodString>;
+  applyInstruction: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+  name: string;
+  applyRequires: string[];
+  artifacts: {
+    id: string;
+    outputPath: string;
+    requires: string[];
+    description?: string | undefined;
+    template?: string | undefined;
+    instruction?: string | undefined;
+  }[];
+  description?: string | undefined;
+  version?: string | number | undefined;
+  applyTracks?: string | undefined;
+  applyInstruction?: string | undefined;
+}, {
+  name: string;
+  applyRequires: string[];
+  artifacts: {
+    id: string;
+    outputPath: string;
+    requires: string[];
+    description?: string | undefined;
+    template?: string | undefined;
+    instruction?: string | undefined;
+  }[];
+  description?: string | undefined;
+  version?: string | number | undefined;
+  applyTracks?: string | undefined;
+  applyInstruction?: string | undefined;
+}>;
+type SchemaDetail = z.infer<typeof SchemaDetailSchema>;
+//#endregion
+//#region src/opsx-entity.d.ts
+type OpsxEntityStage = 'change' | 'archive';
+interface OpsxEntityDiagnostic {
+  level: 'info' | 'warning' | 'error';
+  message: string;
+  path?: string;
+}
+type OpsxEntityFile = ChangeFile;
+type OpsxEntityArtifactFile = ChangeFile & {
+  type: 'file';
+};
+interface OpsxEntityArtifact {
+  id: string;
+  outputPath: string;
+  description?: string;
+  files: OpsxEntityArtifactFile[];
+}
+interface OpsxEntityDetail {
+  stage: OpsxEntityStage;
+  id: string;
+  exists: true;
+  schemaName?: string;
+  files: OpsxEntityFile[];
+  artifacts: OpsxEntityArtifact[];
+  ungroupedFiles: OpsxEntityFile[];
+  diagnostics: OpsxEntityDiagnostic[];
+}
+interface OpsxEntityReadOptions {
+  schemas?: Record<string, SchemaDetail | null | undefined>;
+  schemaDiagnostics?: Record<string, readonly OpsxEntityDiagnostic[] | undefined>;
+}
+declare function getOpsxEntityRootRelativePath(stage: OpsxEntityStage, id: string): string;
+declare function getOpsxEntityMetadataPath(stage: OpsxEntityStage, id: string): string;
+interface ParsedEntityMetadata {
+  schemaName?: string;
+  diagnostics: OpsxEntityDiagnostic[];
+}
+declare function normalizeOpsxEntityPath(path: string): string;
+declare function isOpsxGlobPattern(path: string): boolean;
+declare function opsxGlobToRegex(pattern: string): RegExp;
+declare function opsxPathMatchesPattern(path: string, pattern: string): boolean;
+declare function parseOpsxEntityMetadata(content: string | null | undefined): ParsedEntityMetadata;
+declare function buildOpsxEntityDetail(input: {
+  stage: OpsxEntityStage;
+  id: string;
+  files: ChangeFile[];
+  schemas?: Record<string, SchemaDetail | null | undefined>;
+  schemaDiagnostics?: Record<string, readonly OpsxEntityDiagnostic[] | undefined>;
+}): OpsxEntityDetail;
+//#endregion
+export { SchemaArtifactSchema as A, ArtifactStatus as C, DependencyInfo as D, ChangeStatusSchema as E, SchemaResolution as F, SchemaResolutionSchema as I, TemplatesMap as L, SchemaDetailSchema as M, SchemaInfo as N, DependencyInfoSchema as O, SchemaInfoSchema as P, TemplatesSchema as R, ArtifactInstructionsSchema as S, ChangeStatus as T, ApplyInstructionsContextFilesSchema as _, OpsxEntityFile as a, ApplyTaskSchema as b, buildOpsxEntityDetail as c, isOpsxGlobPattern as d, normalizeOpsxEntityPath as f, ApplyInstructions as g, parseOpsxEntityMetadata as h, OpsxEntityDiagnostic as i, SchemaDetail as j, SchemaArtifact as k, getOpsxEntityMetadataPath as l, opsxPathMatchesPattern as m, OpsxEntityArtifactFile as n, OpsxEntityReadOptions as o, opsxGlobToRegex as p, OpsxEntityDetail as r, OpsxEntityStage as s, OpsxEntityArtifact as t, getOpsxEntityRootRelativePath as u, ApplyInstructionsSchema as v, ArtifactStatusSchema as w, ArtifactInstructions as x, ApplyTask as y, isGlobPattern as z };

package/dist/opsx-entity.d.mts

@@ -0,0 +1,3 @@
+import { a as OpsxEntityFile, c as buildOpsxEntityDetail, d as isOpsxGlobPattern, f as normalizeOpsxEntityPath, h as parseOpsxEntityMetadata, i as OpsxEntityDiagnostic, l as getOpsxEntityMetadataPath, m as opsxPathMatchesPattern, n as OpsxEntityArtifactFile, o as OpsxEntityReadOptions, p as opsxGlobToRegex, r as OpsxEntityDetail, s as OpsxEntityStage, t as OpsxEntityArtifact, u as getOpsxEntityRootRelativePath } from "./opsx-entity-BhvuPO8B.mjs";
+import "./schemas-DZwT0am4.mjs";
+export { OpsxEntityArtifact, OpsxEntityArtifactFile, OpsxEntityDetail, OpsxEntityDiagnostic, OpsxEntityFile, OpsxEntityReadOptions, OpsxEntityStage, buildOpsxEntityDetail, getOpsxEntityMetadataPath, getOpsxEntityRootRelativePath, isOpsxGlobPattern, normalizeOpsxEntityPath, opsxGlobToRegex, opsxPathMatchesPattern, parseOpsxEntityMetadata };