@openspecui/core 3.5.2 → 3.6.0

package/dist/notifications.mjs

@@ -1,5 +1,5 @@
-import "./sounds-C0dNSFm8.mjs";
-import { n as terminalNotificationEventToPublishInput, t as TerminalControlParser } from "./terminal-control-DtBprY6-.mjs";
-import { a as NotificationPublishInputSchema, c as NotificationSoundSchema, d as aggregateNotifications, f as getNotificationAggregateKey, h as groupNotifications, i as NotificationGroupKeySchema, l as NotificationSourceSchema, m as getNotificationGroupLabel, n as NOTIFICATION_SOUND_VALUES, o as NotificationRecordSchema, p as getNotificationGroupKey, r as NotificationActionSchema, s as NotificationSettingsSchema, t as NOTIFICATION_SOUND_OPTIONS, u as TerminalNotificationParser } from "./notifications-F81mmO55.mjs";
+import "./sounds-BzNKMW05.mjs";
+import { n as terminalNotificationEventToPublishInput, t as TerminalControlParser } from "./terminal-control-Bxois59k.mjs";
+import { a as NotificationPublishInputSchema, c as NotificationSoundSchema, d as aggregateNotifications, f as getNotificationAggregateKey, h as groupNotifications, i as NotificationGroupKeySchema, l as NotificationSourceSchema, m as getNotificationGroupLabel, n as NOTIFICATION_SOUND_VALUES, o as NotificationRecordSchema, p as getNotificationGroupKey, r as NotificationActionSchema, s as NotificationSettingsSchema, t as NOTIFICATION_SOUND_OPTIONS, u as TerminalNotificationParser } from "./notifications-fD-V5hyP.mjs";
 
 export { NOTIFICATION_SOUND_OPTIONS, NOTIFICATION_SOUND_VALUES, NotificationActionSchema, NotificationGroupKeySchema, NotificationPublishInputSchema, NotificationRecordSchema, NotificationSettingsSchema, NotificationSoundSchema, NotificationSourceSchema, TerminalControlParser, TerminalNotificationParser, aggregateNotifications, getNotificationAggregateKey, getNotificationGroupKey, getNotificationGroupLabel, groupNotifications, terminalNotificationEventToPublishInput };

package/dist/openspec-annotations-BMy9nWUe.mjs

@@ -0,0 +1,436 @@
+import { t as parseMarkdownFacts } from "./markdown-facts-BmSmZmpB.mjs";
+import { c as getMarkdownHeadingFacts, o as getMarkdownFactSpan, r as createMarkdownReadingDocumentFromFacts, s as getMarkdownHeadingEnd } from "./markdown-reading-CrchEfoW.mjs";
+
+//#region src/openspec-annotations.ts
+const OPEN_SPEC_ANNOTATION_RULES = {
+	documentTitle: "openspec.heading.document-title.v2",
+	purposeSection: "openspec.heading.purpose-section.v2",
+	requirementsSection: "openspec.heading.requirements-section.v2",
+	requirementPrefix: "openspec.heading.requirement-prefix.v2",
+	requirementUnderSection: "openspec.heading.requirement-under-section.v2",
+	requirementCapabilityPrefix: "openspec.heading.capability-prefix.v2",
+	requirementCapabilityText: "openspec.heading.capability-text.v2",
+	scenarioPrefix: "openspec.heading.scenario-prefix.v2",
+	scenarioExamplePrefix: "openspec.heading.example-prefix.v2",
+	scenarioStepHeading: "openspec.heading.step-backed-scenario.v2",
+	scenarioStep: "openspec.list-item.scenario-step.v2",
+	keyword: "openspec.inline.keyword.v2"
+};
+const REQUIREMENT_PREFIX_PATTERN = /^(?:Requirement|Capability):\s*/i;
+const SCENARIO_PREFIX_PATTERN = /^(?:Scenario|Example):\s*/i;
+const SCENARIO_STEP_KEYWORDS = [
+	"GIVEN",
+	"WHEN",
+	"THEN",
+	"AND",
+	"BUT"
+];
+const REQUIREMENT_KEYWORD_PATTERN = new RegExp(`\\b(${[
+	"SHALL",
+	"MUST",
+	"SHOULD",
+	"MAY"
+].join("|")})\\b`, "g");
+const SCENARIO_STEP_PATTERN = new RegExp(`^\\s*(?:[-*+]\\s+)?(?:\\[[ xX]\\]\\s+)?(?:\\*\\*)?(${SCENARIO_STEP_KEYWORDS.join("|")})\\b(?:\\*\\*)?\\s*:?\\s*(.+?)\\s*$`, "i");
+const REQUIREMENT_SECTION_TERMS = [
+	"requirement",
+	"specification",
+	"capability",
+	"capabilities"
+];
+const PURPOSE_SECTION_TERMS = [
+	"purpose",
+	"overview",
+	"objective",
+	"goal",
+	"goals"
+];
+const REQUIREMENT_BODY_SIGNAL_PATTERN = /\b(SHALL|MUST|SHOULD|MAY|CAN|WILL)\b/i;
+const NON_SCENARIO_HEADING_PATTERN = /^(notes?|details?|rationale|reason|migration|examples?|open questions?)$/i;
+const openSpecAnnotationRules = [
+	{
+		id: OPEN_SPEC_ANNOTATION_RULES.documentTitle,
+		annotate(context) {
+			return context.facts.flatMap((fact) => {
+				if (fact.kind !== "heading" || fact.depth !== 1) return [];
+				return [{
+					kind: "document-title",
+					targetFactId: fact.id,
+					confidence: "strong",
+					metadata: { title: fact.text }
+				}];
+			});
+		}
+	},
+	{
+		id: OPEN_SPEC_ANNOTATION_RULES.purposeSection,
+		annotate(context) {
+			return context.facts.flatMap((fact) => {
+				if (fact.kind !== "heading" || fact.depth !== 2) return [];
+				if (!matchesAnyTerm(fact.text, PURPOSE_SECTION_TERMS)) return [];
+				return [{
+					kind: "purpose-section",
+					targetFactId: fact.id,
+					confidence: isExactTerm(fact.text, ["Purpose", "Overview"]) ? "strong" : "weak",
+					metadata: { title: fact.text }
+				}];
+			});
+		}
+	},
+	{
+		id: OPEN_SPEC_ANNOTATION_RULES.requirementsSection,
+		annotate(context) {
+			return context.facts.flatMap((fact) => {
+				if (fact.kind !== "heading" || fact.depth !== 2) return [];
+				if (!matchesAnyTerm(fact.text, REQUIREMENT_SECTION_TERMS)) return [];
+				return [{
+					kind: "requirements-section",
+					targetFactId: fact.id,
+					confidence: fact.text.toLowerCase().includes("requirement") ? "strong" : "weak",
+					metadata: { title: fact.text }
+				}];
+			});
+		}
+	},
+	{
+		id: OPEN_SPEC_ANNOTATION_RULES.requirementPrefix,
+		annotate(context) {
+			return context.facts.flatMap((fact) => {
+				if (fact.kind !== "heading" || fact.depth !== 3) return [];
+				if (!/^Requirement:\s*/i.test(fact.text)) return [];
+				return [createRequirementAnnotation(fact, "strong")];
+			});
+		}
+	},
+	{
+		id: OPEN_SPEC_ANNOTATION_RULES.requirementCapabilityPrefix,
+		annotate(context) {
+			return context.facts.flatMap((fact) => {
+				if (fact.kind !== "heading" || fact.depth !== 3) return [];
+				if (!/^Capability:\s*/i.test(fact.text)) return [];
+				return [createRequirementAnnotation(fact, "weak")];
+			});
+		}
+	},
+	{
+		id: OPEN_SPEC_ANNOTATION_RULES.requirementUnderSection,
+		annotate(context) {
+			return getRequirementSections(context).flatMap((section) => {
+				return getChildHeadings(context, section, 3).flatMap((fact) => {
+					if (context.getAnnotation(fact.id, "requirement")) return [];
+					if (REQUIREMENT_PREFIX_PATTERN.test(fact.text)) return [];
+					if (!hasRequirementBodySignals(context, fact, section.end)) return [];
+					return [{
+						kind: "requirement",
+						targetFactId: fact.id,
+						confidence: "weak",
+						metadata: { title: fact.text }
+					}];
+				});
+			});
+		}
+	},
+	{
+		id: OPEN_SPEC_ANNOTATION_RULES.requirementCapabilityText,
+		annotate(context) {
+			return getRequirementSections(context).flatMap((section) => {
+				return getChildHeadings(context, section, 3).flatMap((fact) => {
+					if (context.getAnnotation(fact.id, "requirement")) return [];
+					if (!matchesAnyTerm(fact.text, [
+						"capability",
+						"feature",
+						"behavior"
+					])) return [];
+					return [{
+						kind: "requirement",
+						targetFactId: fact.id,
+						confidence: "weak",
+						metadata: { title: stripRequirementPrefix(fact.text) || fact.text }
+					}];
+				});
+			});
+		}
+	},
+	{
+		id: OPEN_SPEC_ANNOTATION_RULES.scenarioPrefix,
+		annotate(context) {
+			return getRequirementHeadings(context).flatMap((requirement) => {
+				return getNestedHeadings(context, requirement).flatMap((fact) => {
+					if (fact.depth !== 4 || !/^Scenario:\s*/i.test(fact.text)) return [];
+					return [createScenarioAnnotation(fact, "strong")];
+				});
+			});
+		}
+	},
+	{
+		id: OPEN_SPEC_ANNOTATION_RULES.scenarioExamplePrefix,
+		annotate(context) {
+			return getRequirementHeadings(context).flatMap((requirement) => {
+				return getNestedHeadings(context, requirement).flatMap((fact) => {
+					if (fact.depth !== 4 || !/^Example:\s*/i.test(fact.text)) return [];
+					return [createScenarioAnnotation(fact, "weak")];
+				});
+			});
+		}
+	},
+	{
+		id: OPEN_SPEC_ANNOTATION_RULES.scenarioStepHeading,
+		annotate(context) {
+			return getRequirementHeadings(context).flatMap((requirement) => {
+				return getNestedHeadings(context, requirement).flatMap((fact) => {
+					if (fact.depth !== 4) return [];
+					if (context.getAnnotation(fact.id, "scenario")) return [];
+					if (NON_SCENARIO_HEADING_PATTERN.test(fact.text)) return [];
+					if (!hasScenarioStepSignals(context, fact)) return [];
+					return [{
+						kind: "scenario",
+						targetFactId: fact.id,
+						confidence: "weak",
+						metadata: { title: stripScenarioPrefix(fact.text) || fact.text }
+					}];
+				});
+			});
+		}
+	},
+	{
+		id: OPEN_SPEC_ANNOTATION_RULES.scenarioStep,
+		annotate(context) {
+			const scenarioSections = getScenarioSections(context);
+			return context.facts.flatMap((fact) => {
+				if (fact.kind !== "listItem") return [];
+				if (!isWithinAnySection(fact, scenarioSections)) return [];
+				const metadata = parseScenarioStepFact(fact);
+				if (!metadata) return [];
+				return [{
+					kind: "scenario-step",
+					targetFactId: fact.id,
+					confidence: "strong",
+					metadata
+				}];
+			});
+		}
+	},
+	{
+		id: OPEN_SPEC_ANNOTATION_RULES.keyword,
+		annotate(context) {
+			const scenarioKeywordAnnotations = context.previousAnnotations.flatMap((annotation) => {
+				if (annotation.kind !== "scenario-step") return [];
+				const fact = context.factById.get(annotation.targetFactId);
+				if (!fact) return [];
+				return findScenarioStepKeyword(fact, readAnnotationKeyword(annotation.metadata));
+			});
+			const requirementKeywordAnnotations = context.facts.flatMap((fact) => {
+				if (!canAnnotateInlineKeywords(fact)) return [];
+				return findRequirementKeywords(fact);
+			});
+			return [...scenarioKeywordAnnotations, ...requirementKeywordAnnotations];
+		}
+	}
+];
+const builtinOpenSpecReadingPlugin = {
+	id: "openspec.builtin-reading.v2",
+	annotationRules: openSpecAnnotationRules
+};
+function annotateOpenSpecMarkdown(sourceMarkdown, plugins = [builtinOpenSpecReadingPlugin]) {
+	return annotateOpenSpecFacts(parseMarkdownFacts(sourceMarkdown), plugins);
+}
+function annotateOpenSpecFacts(document, plugins = [builtinOpenSpecReadingPlugin]) {
+	const readingDocument = createMarkdownReadingDocumentFromFacts(document, plugins);
+	return {
+		...readingDocument,
+		annotations: readingDocument.annotations.filter(isOpenSpecAnnotation)
+	};
+}
+function getOpenSpecAnnotationsForFact(document, factId) {
+	return document.annotations.filter((annotation) => annotation.targetFactId === factId);
+}
+function getOpenSpecAnnotation(document, factId, kind) {
+	return document.annotations.find((annotation) => annotation.targetFactId === factId && annotation.kind === kind);
+}
+function isOpenSpecAnnotation(annotation) {
+	return annotation.kind === "document-title" || annotation.kind === "purpose-section" || annotation.kind === "requirements-section" || annotation.kind === "requirement" || annotation.kind === "scenario" || annotation.kind === "scenario-step" || annotation.kind === "keyword";
+}
+function createRequirementAnnotation(fact, confidence) {
+	return {
+		kind: "requirement",
+		targetFactId: fact.id,
+		confidence,
+		metadata: { title: stripRequirementPrefix(fact.text) || fact.text }
+	};
+}
+function createScenarioAnnotation(fact, confidence) {
+	return {
+		kind: "scenario",
+		targetFactId: fact.id,
+		confidence,
+		metadata: { title: stripScenarioPrefix(fact.text) || "Scenario" }
+	};
+}
+function matchesAnyTerm(text, terms) {
+	const normalized = text.toLowerCase();
+	return terms.some((term) => normalized.includes(term));
+}
+function isExactTerm(text, terms) {
+	const normalized = text.trim().toLowerCase();
+	return terms.some((term) => normalized === term.toLowerCase());
+}
+function stripRequirementPrefix(text) {
+	return text.replace(REQUIREMENT_PREFIX_PATTERN, "").trim();
+}
+function stripScenarioPrefix(text) {
+	return text.replace(SCENARIO_PREFIX_PATTERN, "").trim();
+}
+function getHeadingSections(context) {
+	const headings = getMarkdownHeadingFacts(context);
+	return headings.reduce((sections, fact, index) => {
+		const span = getMarkdownFactSpan(fact);
+		if (!span) return sections;
+		sections.push({
+			fact,
+			start: span.start,
+			end: getMarkdownHeadingEnd(headings, index, context.sourceMarkdown.length)
+		});
+		return sections;
+	}, []);
+}
+function getRequirementSections(context) {
+	return getHeadingSections(context).filter((section) => context.getAnnotation(section.fact.id, "requirements-section"));
+}
+function getChildHeadings(context, section, depth) {
+	return getMarkdownHeadingFacts(context).filter((fact) => {
+		if (fact.depth !== depth) return false;
+		const span = getMarkdownFactSpan(fact);
+		return !!span && span.start > section.start && span.start < section.end;
+	});
+}
+function getRequirementHeadings(context) {
+	return getMarkdownHeadingFacts(context).filter((fact) => context.getAnnotation(fact.id, "requirement"));
+}
+function getNestedHeadings(context, parentHeading) {
+	const headings = getMarkdownHeadingFacts(context);
+	const parentIndex = headings.findIndex((fact) => fact.id === parentHeading.id);
+	const parentSpan = getMarkdownFactSpan(parentHeading);
+	if (parentIndex < 0 || !parentSpan) return [];
+	const end = getMarkdownHeadingEnd(headings, parentIndex, context.sourceMarkdown.length);
+	return headings.filter((fact) => {
+		const span = getMarkdownFactSpan(fact);
+		return !!span && span.start > parentSpan.start && span.start < end;
+	});
+}
+function getScenarioSections(context) {
+	const headings = getMarkdownHeadingFacts(context);
+	return getHeadingSections(context).filter((section) => {
+		if (!context.getAnnotation(section.fact.id, "scenario")) return false;
+		if (NON_SCENARIO_HEADING_PATTERN.test(section.fact.text)) return false;
+		return headings.findIndex((fact) => fact.id === section.fact.id) >= 0;
+	});
+}
+function hasRequirementBodySignals(context, requirementHeading, sectionEnd) {
+	const span = getMarkdownFactSpan(requirementHeading);
+	if (!span) return false;
+	const headings = getMarkdownHeadingFacts(context);
+	const index = headings.findIndex((fact) => fact.id === requirementHeading.id);
+	const end = index >= 0 ? getMarkdownHeadingEnd(headings, index, sectionEnd) : sectionEnd;
+	const body = context.sourceMarkdown.slice(span.end, Math.min(end, sectionEnd));
+	return REQUIREMENT_BODY_SIGNAL_PATTERN.test(body);
+}
+function hasScenarioStepSignals(context, scenarioHeading) {
+	const span = getMarkdownFactSpan(scenarioHeading);
+	if (!span) return false;
+	const headings = getMarkdownHeadingFacts(context);
+	const index = headings.findIndex((fact) => fact.id === scenarioHeading.id);
+	const end = index >= 0 ? getMarkdownHeadingEnd(headings, index, context.sourceMarkdown.length) : context.sourceMarkdown.length;
+	return context.sourceMarkdown.slice(span.end, end).split("\n").some((line) => SCENARIO_STEP_PATTERN.test(line));
+}
+function isWithinAnySection(fact, sections) {
+	const span = getMarkdownFactSpan(fact);
+	if (!span) return false;
+	return sections.some((section) => span.start > section.start && span.start < section.end);
+}
+function parseScenarioStepFact(fact) {
+	const rawMarkdown = fact.range?.rawMarkdown.trim() || fact.text;
+	const match = rawMarkdown.match(SCENARIO_STEP_PATTERN) ?? fact.text.match(SCENARIO_STEP_PATTERN);
+	if (!match) return void 0;
+	return {
+		keyword: match[1].toUpperCase(),
+		contentMarkdown: match[2].trim(),
+		rawMarkdown
+	};
+}
+function canAnnotateInlineKeywords(fact) {
+	return fact.kind === "paragraph" || fact.kind === "listItem" || fact.kind === "heading" || fact.kind === "tableCell";
+}
+function findScenarioStepKeyword(fact, keyword) {
+	if (!isScenarioStepKeywordValue(keyword)) return [];
+	const match = fact.text.match(new RegExp(`^\\s*(${SCENARIO_STEP_KEYWORDS.join("|")})\\b`, "i"));
+	if (!match) return [];
+	const text = match[1];
+	const textStart = match.index ?? 0;
+	const sourceSpan = findSourceSpanForFactText(fact, text);
+	return [{
+		kind: "keyword",
+		targetFactId: fact.id,
+		...sourceSpan ? { sourceSpan } : {},
+		textSpan: {
+			start: textStart,
+			end: textStart + text.length
+		},
+		confidence: "strong",
+		metadata: {
+			keyword,
+			keywordText: text,
+			keywordRole: "scenario-step"
+		}
+	}];
+}
+function findRequirementKeywords(fact) {
+	const span = getMarkdownFactSpan(fact);
+	const text = fact.text;
+	if (!span || !text) return [];
+	return Array.from(text.matchAll(REQUIREMENT_KEYWORD_PATTERN), (match) => {
+		const keyword = match[1].toUpperCase();
+		const textStart = match.index;
+		const textEnd = textStart + match[1].length;
+		const sourceSpan = findSourceSpanForFactText(fact, match[1], textStart);
+		return {
+			kind: "keyword",
+			targetFactId: fact.id,
+			...sourceSpan ? { sourceSpan } : {},
+			textSpan: {
+				start: textStart,
+				end: textEnd
+			},
+			confidence: "strong",
+			metadata: {
+				keyword,
+				keywordText: match[1],
+				keywordRole: isScenarioStepKeyword(keyword) ? "scenario-step" : "requirement-modal"
+			}
+		};
+	});
+}
+function isScenarioStepKeywordValue(value) {
+	return typeof value === "string" && SCENARIO_STEP_KEYWORDS.some((stepKeyword) => stepKeyword === value);
+}
+function isScenarioStepKeyword(keyword) {
+	return SCENARIO_STEP_KEYWORDS.some((stepKeyword) => stepKeyword === keyword);
+}
+function readAnnotationKeyword(metadata) {
+	return metadata && "keyword" in metadata ? metadata.keyword : void 0;
+}
+function findSourceSpanForFactText(fact, text, textStart = 0) {
+	const factSpan = getMarkdownFactSpan(fact);
+	const rawMarkdown = fact.range?.rawMarkdown;
+	if (!factSpan || !rawMarkdown) return void 0;
+	const rawStart = rawMarkdown.indexOf(text, Math.min(textStart, rawMarkdown.length));
+	const index = rawStart >= 0 ? rawStart : rawMarkdown.indexOf(text);
+	if (index < 0) return void 0;
+	const start = factSpan.start + index;
+	return {
+		start,
+		end: start + text.length
+	};
+}
+
+//#endregion
+export { getOpenSpecAnnotationsForFact as a, getOpenSpecAnnotation as i, annotateOpenSpecMarkdown as n, openSpecAnnotationRules as o, builtinOpenSpecReadingPlugin as r, annotateOpenSpecFacts as t };

package/dist/openspec-annotations-CJmYcfAu.d.mts

@@ -0,0 +1,30 @@
+import { r as MarkdownFactsDocument } from "./markdown-facts-f3kXnqXb.mjs";
+import { a as MarkdownAnnotationRule, d as MarkdownReadingPlugin, l as MarkdownReadingDocument, n as MarkdownAnnotationConfidence, t as MarkdownAnnotation } from "./markdown-reading-D36W693c.mjs";
+
+//#region src/openspec-annotations.d.ts
+type OpenSpecSemanticKind = 'document-title' | 'purpose-section' | 'requirements-section' | 'requirement' | 'scenario' | 'scenario-step' | 'keyword';
+type OpenSpecAnnotationConfidence = MarkdownAnnotationConfidence;
+type OpenSpecScenarioStepKeyword = 'GIVEN' | 'WHEN' | 'THEN' | 'AND' | 'BUT';
+type OpenSpecRequirementKeyword = 'SHALL' | 'MUST' | 'SHOULD' | 'MAY';
+type OpenSpecKeyword = OpenSpecScenarioStepKeyword | OpenSpecRequirementKeyword;
+type OpenSpecKeywordRole = 'scenario-step' | 'requirement-modal';
+interface OpenSpecAnnotationMetadata {
+  title?: string;
+  keyword?: OpenSpecKeyword;
+  keywordText?: string;
+  keywordRole?: OpenSpecKeywordRole;
+  contentMarkdown?: string;
+  rawMarkdown?: string;
+}
+type OpenSpecAnnotation = MarkdownAnnotation<OpenSpecSemanticKind, OpenSpecAnnotationMetadata>;
+interface AnnotatedOpenSpecDocument extends MarkdownReadingDocument {
+  annotations: OpenSpecAnnotation[];
+}
+declare const openSpecAnnotationRules: readonly MarkdownAnnotationRule[];
+declare const builtinOpenSpecReadingPlugin: MarkdownReadingPlugin;
+declare function annotateOpenSpecMarkdown(sourceMarkdown: string, plugins?: readonly MarkdownReadingPlugin[]): AnnotatedOpenSpecDocument;
+declare function annotateOpenSpecFacts(document: MarkdownFactsDocument, plugins?: readonly MarkdownReadingPlugin[]): AnnotatedOpenSpecDocument;
+declare function getOpenSpecAnnotationsForFact(document: AnnotatedOpenSpecDocument, factId: string): OpenSpecAnnotation[];
+declare function getOpenSpecAnnotation(document: AnnotatedOpenSpecDocument, factId: string, kind: OpenSpecSemanticKind): OpenSpecAnnotation | undefined;
+//#endregion
+export { OpenSpecKeyword as a, OpenSpecScenarioStepKeyword as c, annotateOpenSpecMarkdown as d, builtinOpenSpecReadingPlugin as f, openSpecAnnotationRules as h, OpenSpecAnnotationMetadata as i, OpenSpecSemanticKind as l, getOpenSpecAnnotationsForFact as m, OpenSpecAnnotation as n, OpenSpecKeywordRole as o, getOpenSpecAnnotation as p, OpenSpecAnnotationConfidence as r, OpenSpecRequirementKeyword as s, AnnotatedOpenSpecDocument as t, annotateOpenSpecFacts as u };

package/dist/openspec-annotations.d.mts

@@ -0,0 +1,4 @@
+import "./markdown-facts-f3kXnqXb.mjs";
+import "./markdown-reading-D36W693c.mjs";
+import { a as OpenSpecKeyword, c as OpenSpecScenarioStepKeyword, d as annotateOpenSpecMarkdown, f as builtinOpenSpecReadingPlugin, h as openSpecAnnotationRules, i as OpenSpecAnnotationMetadata, l as OpenSpecSemanticKind, m as getOpenSpecAnnotationsForFact, n as OpenSpecAnnotation, o as OpenSpecKeywordRole, p as getOpenSpecAnnotation, r as OpenSpecAnnotationConfidence, s as OpenSpecRequirementKeyword, t as AnnotatedOpenSpecDocument, u as annotateOpenSpecFacts } from "./openspec-annotations-CJmYcfAu.mjs";
+export { AnnotatedOpenSpecDocument, OpenSpecAnnotation, OpenSpecAnnotationConfidence, OpenSpecAnnotationMetadata, OpenSpecKeyword, OpenSpecKeywordRole, OpenSpecRequirementKeyword, OpenSpecScenarioStepKeyword, OpenSpecSemanticKind, annotateOpenSpecFacts, annotateOpenSpecMarkdown, builtinOpenSpecReadingPlugin, getOpenSpecAnnotation, getOpenSpecAnnotationsForFact, openSpecAnnotationRules };

package/dist/openspec-annotations.mjs

@@ -0,0 +1,5 @@
+import "./markdown-facts-BmSmZmpB.mjs";
+import "./markdown-reading-CrchEfoW.mjs";
+import { a as getOpenSpecAnnotationsForFact, i as getOpenSpecAnnotation, n as annotateOpenSpecMarkdown, o as openSpecAnnotationRules, r as builtinOpenSpecReadingPlugin, t as annotateOpenSpecFacts } from "./openspec-annotations-BMy9nWUe.mjs";
+
+export { annotateOpenSpecFacts, annotateOpenSpecMarkdown, builtinOpenSpecReadingPlugin, getOpenSpecAnnotation, getOpenSpecAnnotationsForFact, openSpecAnnotationRules };