@contractspec/module.workspace 1.44.0

package/dist/analysis/diff/deep-diff.js

@@ -0,0 +1,114 @@
+//#region src/analysis/diff/deep-diff.ts
+/**
+* Compute deep differences between two IO schemas.
+*/
+function computeIoDiff(base, head, options = {}) {
+	const diffs = [];
+	diffs.push(...computeFieldsDiff(base.input, head.input, "io.input", options));
+	diffs.push(...computeFieldsDiff(base.output, head.output, "io.output", options));
+	return options.breakingOnly ? diffs.filter((d) => d.type === "breaking") : diffs;
+}
+/**
+* Compute differences between two field maps.
+*/
+function computeFieldsDiff(baseFields, headFields, pathPrefix, options = {}) {
+	const diffs = [];
+	const baseNames = new Set(Object.keys(baseFields));
+	const headNames = new Set(Object.keys(headFields));
+	for (const name of baseNames) if (!headNames.has(name)) {
+		const baseField = baseFields[name];
+		diffs.push({
+			type: "breaking",
+			path: `${pathPrefix}.${name}`,
+			oldValue: baseField,
+			newValue: void 0,
+			description: `Field '${name}' was removed`
+		});
+	}
+	for (const name of headNames) if (!baseNames.has(name)) {
+		const headField = headFields[name];
+		const isBreaking = headField?.required === true;
+		diffs.push({
+			type: isBreaking ? "breaking" : "added",
+			path: `${pathPrefix}.${name}`,
+			oldValue: void 0,
+			newValue: headField,
+			description: isBreaking ? `Required field '${name}' was added` : `Optional field '${name}' was added`
+		});
+	}
+	for (const name of baseNames) if (headNames.has(name)) {
+		const baseField = baseFields[name];
+		const headField = headFields[name];
+		if (baseField && headField) diffs.push(...computeFieldDiff(baseField, headField, `${pathPrefix}.${name}`, options));
+	}
+	return diffs;
+}
+/**
+* Compute differences between two field definitions.
+*/
+function computeFieldDiff(base, head, path, _options = {}) {
+	const diffs = [];
+	if (base.type !== head.type) diffs.push({
+		type: "breaking",
+		path: `${path}.type`,
+		oldValue: base.type,
+		newValue: head.type,
+		description: `Field type changed from '${base.type}' to '${head.type}'`
+	});
+	if (base.required !== head.required) {
+		const isBreaking = !base.required && head.required;
+		diffs.push({
+			type: isBreaking ? "breaking" : "changed",
+			path: `${path}.required`,
+			oldValue: base.required,
+			newValue: head.required,
+			description: isBreaking ? `Field '${base.name}' changed from optional to required` : `Field '${base.name}' changed from required to optional`
+		});
+	}
+	if (base.nullable !== head.nullable) {
+		const isBreaking = base.nullable && !head.nullable;
+		diffs.push({
+			type: isBreaking ? "breaking" : "changed",
+			path: `${path}.nullable`,
+			oldValue: base.nullable,
+			newValue: head.nullable,
+			description: isBreaking ? `Field '${base.name}' is no longer nullable` : `Field '${base.name}' is now nullable`
+		});
+	}
+	if (base.type === "enum" && head.type === "enum") {
+		const baseValues = new Set(base.enumValues ?? []);
+		const headValues = new Set(head.enumValues ?? []);
+		for (const value of baseValues) if (!headValues.has(value)) diffs.push({
+			type: "breaking",
+			path: `${path}.enumValues`,
+			oldValue: base.enumValues,
+			newValue: head.enumValues,
+			description: `Enum value '${value}' was removed`
+		});
+		for (const value of headValues) if (!baseValues.has(value)) diffs.push({
+			type: "added",
+			path: `${path}.enumValues`,
+			oldValue: base.enumValues,
+			newValue: head.enumValues,
+			description: `Enum value '${value}' was added`
+		});
+	}
+	if (base.type === "object" && head.type === "object" && base.properties && head.properties) diffs.push(...computeFieldsDiff(base.properties, head.properties, path, _options));
+	if (base.type === "array" && head.type === "array" && base.items && head.items) diffs.push(...computeFieldDiff(base.items, head.items, `${path}.items`, _options));
+	return diffs;
+}
+/**
+* Classify a diff as breaking based on context.
+*/
+function isBreakingChange(diff, context) {
+	if (context === "output") return diff.type === "breaking" || diff.type === "removed";
+	if (context === "input") {
+		if (diff.type === "added" && diff.description?.includes("Required field")) return true;
+		return diff.type === "breaking";
+	}
+	return diff.type === "breaking";
+}
+
+//#endregion
+export { computeFieldDiff, computeFieldsDiff, computeIoDiff, isBreakingChange };
+//# sourceMappingURL=deep-diff.js.map

package/dist/analysis/diff/deep-diff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-diff.js","names":["diffs: SemanticDiffItem[]"],"sources":["../../../src/analysis/diff/deep-diff.ts"],"sourcesContent":["/**\n * Deep diff engine for IO schema comparison.\n *\n * Compares input/output schemas field-by-field to detect\n * breaking and non-breaking changes.\n */\n\nimport type { FieldSnapshot, IoSnapshot } from '../snapshot/types';\nimport type { SemanticDiffItem } from '../../types/analysis-types';\n\n/**\n * Deep diff options.\n */\nexport interface DeepDiffOptions {\n  /** Only report breaking changes */\n  breakingOnly?: boolean;\n  /** Path prefix for nested diffs */\n  pathPrefix?: string;\n}\n\n/**\n * Compute deep differences between two IO schemas.\n */\nexport function computeIoDiff(\n  base: IoSnapshot,\n  head: IoSnapshot,\n  options: DeepDiffOptions = {}\n): SemanticDiffItem[] {\n  const diffs: SemanticDiffItem[] = [];\n\n  // Compare input schemas\n  diffs.push(...computeFieldsDiff(base.input, head.input, 'io.input', options));\n\n  // Compare output schemas\n  diffs.push(\n    ...computeFieldsDiff(base.output, head.output, 'io.output', options)\n  );\n\n  return options.breakingOnly\n    ? diffs.filter((d) => d.type === 'breaking')\n    : diffs;\n}\n\n/**\n * Compute differences between two field maps.\n */\nexport function computeFieldsDiff(\n  baseFields: Record<string, FieldSnapshot>,\n  headFields: Record<string, FieldSnapshot>,\n  pathPrefix: string,\n  options: DeepDiffOptions = {}\n): SemanticDiffItem[] {\n  const diffs: SemanticDiffItem[] = [];\n  const baseNames = new Set(Object.keys(baseFields));\n  const headNames = new Set(Object.keys(headFields));\n\n  // Check for removed fields\n  for (const name of baseNames) {\n    if (!headNames.has(name)) {\n      const baseField = baseFields[name];\n      diffs.push({\n        type: 'breaking',\n        path: `${pathPrefix}.${name}`,\n        oldValue: baseField,\n        newValue: undefined,\n        description: `Field '${name}' was removed`,\n      });\n    }\n  }\n\n  // Check for added fields\n  for (const name of headNames) {\n    if (!baseNames.has(name)) {\n      const headField = headFields[name];\n      const isBreaking = headField?.required === true;\n      diffs.push({\n        type: isBreaking ? 'breaking' : 'added',\n        path: `${pathPrefix}.${name}`,\n        oldValue: undefined,\n        newValue: headField,\n        description: isBreaking\n          ? `Required field '${name}' was added`\n          : `Optional field '${name}' was added`,\n      });\n    }\n  }\n\n  // Check for changed fields\n  for (const name of baseNames) {\n    if (headNames.has(name)) {\n      const baseField = baseFields[name];\n      const headField = headFields[name];\n      if (baseField && headField) {\n        diffs.push(\n          ...computeFieldDiff(\n            baseField,\n            headField,\n            `${pathPrefix}.${name}`,\n            options\n          )\n        );\n      }\n    }\n  }\n\n  return diffs;\n}\n\n/**\n * Compute differences between two field definitions.\n */\nexport function computeFieldDiff(\n  base: FieldSnapshot,\n  head: FieldSnapshot,\n  path: string,\n  _options: DeepDiffOptions = {}\n): SemanticDiffItem[] {\n  const diffs: SemanticDiffItem[] = [];\n\n  // Type change is always breaking\n  if (base.type !== head.type) {\n    diffs.push({\n      type: 'breaking',\n      path: `${path}.type`,\n      oldValue: base.type,\n      newValue: head.type,\n      description: `Field type changed from '${base.type}' to '${head.type}'`,\n    });\n  }\n\n  // Required change\n  if (base.required !== head.required) {\n    const isBreaking = !base.required && head.required; // Optional -> Required is breaking\n    diffs.push({\n      type: isBreaking ? 'breaking' : 'changed',\n      path: `${path}.required`,\n      oldValue: base.required,\n      newValue: head.required,\n      description: isBreaking\n        ? `Field '${base.name}' changed from optional to required`\n        : `Field '${base.name}' changed from required to optional`,\n    });\n  }\n\n  // Nullable change\n  if (base.nullable !== head.nullable) {\n    const isBreaking = base.nullable && !head.nullable; // Nullable -> Non-nullable is breaking\n    diffs.push({\n      type: isBreaking ? 'breaking' : 'changed',\n      path: `${path}.nullable`,\n      oldValue: base.nullable,\n      newValue: head.nullable,\n      description: isBreaking\n        ? `Field '${base.name}' is no longer nullable`\n        : `Field '${base.name}' is now nullable`,\n    });\n  }\n\n  // Enum values change\n  if (base.type === 'enum' && head.type === 'enum') {\n    const baseValues = new Set(base.enumValues ?? []);\n    const headValues = new Set(head.enumValues ?? []);\n\n    // Removed enum values are breaking\n    for (const value of baseValues) {\n      if (!headValues.has(value)) {\n        diffs.push({\n          type: 'breaking',\n          path: `${path}.enumValues`,\n          oldValue: base.enumValues,\n          newValue: head.enumValues,\n          description: `Enum value '${value}' was removed`,\n        });\n      }\n    }\n\n    // Added enum values are non-breaking\n    for (const value of headValues) {\n      if (!baseValues.has(value)) {\n        diffs.push({\n          type: 'added',\n          path: `${path}.enumValues`,\n          oldValue: base.enumValues,\n          newValue: head.enumValues,\n          description: `Enum value '${value}' was added`,\n        });\n      }\n    }\n  }\n\n  // Nested object fields\n  if (\n    base.type === 'object' &&\n    head.type === 'object' &&\n    base.properties &&\n    head.properties\n  ) {\n    diffs.push(\n      ...computeFieldsDiff(base.properties, head.properties, path, _options)\n    );\n  }\n\n  // Array items\n  if (\n    base.type === 'array' &&\n    head.type === 'array' &&\n    base.items &&\n    head.items\n  ) {\n    diffs.push(\n      ...computeFieldDiff(base.items, head.items, `${path}.items`, _options)\n    );\n  }\n\n  return diffs;\n}\n\n/**\n * Classify a diff as breaking based on context.\n */\nexport function isBreakingChange(\n  diff: SemanticDiffItem,\n  context: 'input' | 'output'\n): boolean {\n  // In output context, removing/changing fields is always breaking\n  if (context === 'output') {\n    return diff.type === 'breaking' || diff.type === 'removed';\n  }\n\n  // In input context, adding required fields is breaking\n  if (context === 'input') {\n    if (diff.type === 'added' && diff.description?.includes('Required field')) {\n      return true;\n    }\n    return diff.type === 'breaking';\n  }\n\n  return diff.type === 'breaking';\n}\n"],"mappings":"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"}

package/dist/analysis/diff/semantic.d.ts

@@ -0,0 +1,11 @@
+import { SemanticDiffItem, SemanticDiffOptions } from "../../types/analysis-types.js";
+
+//#region src/analysis/diff/semantic.d.ts
+
+/**
+ * Compute semantic differences between two spec sources.
+ */
+declare function computeSemanticDiff(aCode: string, aPath: string, bCode: string, bPath: string, options?: SemanticDiffOptions): SemanticDiffItem[];
+//#endregion
+export { computeSemanticDiff };
+//# sourceMappingURL=semantic.d.ts.map

package/dist/analysis/diff/semantic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic.d.ts","names":[],"sources":["../../../src/analysis/diff/semantic.ts"],"sourcesContent":[],"mappings":";;;;;;;iBAegB,mBAAA,uEAKL,sBACR"}

package/dist/analysis/diff/semantic.js

@@ -0,0 +1,97 @@
+import { scanSpecSource } from "../spec-scan.js";
+
+//#region src/analysis/diff/semantic.ts
+/**
+* Compute semantic differences between two spec sources.
+*/
+function computeSemanticDiff(aCode, aPath, bCode, bPath, options = {}) {
+	const a = scanSpecSource(aCode, aPath);
+	const b = scanSpecSource(bCode, bPath);
+	const diffs = [];
+	compareScalar(diffs, "specType", a.specType, b.specType, {
+		breaking: true,
+		label: "Spec type"
+	});
+	compareScalar(diffs, "key", a.key, b.key, {
+		breaking: true,
+		label: "Key"
+	});
+	compareScalar(diffs, "version", a.version, b.version, {
+		breaking: true,
+		label: "Version"
+	});
+	compareScalar(diffs, "kind", a.kind, b.kind, {
+		breaking: true,
+		label: "Kind"
+	});
+	compareScalar(diffs, "stability", a.stability, b.stability, {
+		breaking: isStabilityDowngrade(a, b),
+		label: "Stability"
+	});
+	compareArray(diffs, "owners", a.owners ?? [], b.owners ?? [], { label: "Owners" });
+	compareArray(diffs, "tags", a.tags ?? [], b.tags ?? [], { label: "Tags" });
+	compareStructuralHints(diffs, a, b);
+	return options.breakingOnly ? diffs.filter((d) => d.type === "breaking") : diffs;
+}
+function compareScalar(diffs, path, a, b, config) {
+	if (a === b) return;
+	diffs.push({
+		type: config.breaking ? "breaking" : "changed",
+		path,
+		oldValue: a,
+		newValue: b,
+		description: `${config.label} changed`
+	});
+}
+function compareArray(diffs, path, a, b, config) {
+	const aSorted = [...a].sort();
+	const bSorted = [...b].sort();
+	if (JSON.stringify(aSorted) === JSON.stringify(bSorted)) return;
+	diffs.push({
+		type: "changed",
+		path,
+		oldValue: aSorted,
+		newValue: bSorted,
+		description: `${config.label} changed`
+	});
+}
+function isStabilityDowngrade(a, b) {
+	const order = {
+		experimental: 0,
+		beta: 1,
+		stable: 2,
+		deprecated: 3
+	};
+	const aValue = a.stability ? order[a.stability] ?? 0 : 0;
+	return (b.stability ? order[b.stability] ?? 0 : 0) > aValue;
+}
+function compareStructuralHints(diffs, a, b) {
+	compareScalar(diffs, "hasMeta", a.hasMeta, b.hasMeta, {
+		breaking: a.specType === "operation" || b.specType === "operation",
+		label: "meta section presence"
+	});
+	compareScalar(diffs, "hasIo", a.hasIo, b.hasIo, {
+		breaking: a.specType === "operation" || b.specType === "operation",
+		label: "io section presence"
+	});
+	compareScalar(diffs, "hasPolicy", a.hasPolicy, b.hasPolicy, {
+		breaking: a.specType === "operation" || b.specType === "operation",
+		label: "policy section presence"
+	});
+	compareScalar(diffs, "hasPayload", a.hasPayload, b.hasPayload, {
+		breaking: a.specType === "event" || b.specType === "event",
+		label: "payload section presence"
+	});
+	compareScalar(diffs, "hasContent", a.hasContent, b.hasContent, {
+		breaking: a.specType === "presentation" || b.specType === "presentation",
+		label: "content section presence"
+	});
+	compareScalar(diffs, "hasDefinition", a.hasDefinition, b.hasDefinition, {
+		breaking: a.specType === "workflow" || b.specType === "workflow",
+		label: "definition section presence"
+	});
+}
+
+//#endregion
+export { computeSemanticDiff };
+//# sourceMappingURL=semantic.js.map

package/dist/analysis/diff/semantic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic.js","names":["diffs: SemanticDiffItem[]","order: Record<string, number>"],"sources":["../../../src/analysis/diff/semantic.ts"],"sourcesContent":["/**\n * Semantic diff computation for contract specs.\n * Extracted from cli-contractspec/src/commands/diff/semantic.ts\n */\n\nimport type {\n  SemanticDiffItem,\n  SemanticDiffOptions,\n  SpecScanResult,\n} from '../../types/analysis-types';\nimport { scanSpecSource } from '../spec-scan';\n\n/**\n * Compute semantic differences between two spec sources.\n */\nexport function computeSemanticDiff(\n  aCode: string,\n  aPath: string,\n  bCode: string,\n  bPath: string,\n  options: SemanticDiffOptions = {}\n): SemanticDiffItem[] {\n  const a = scanSpecSource(aCode, aPath);\n  const b = scanSpecSource(bCode, bPath);\n\n  const diffs: SemanticDiffItem[] = [];\n\n  compareScalar(diffs, 'specType', a.specType, b.specType, {\n    breaking: true,\n    label: 'Spec type',\n  });\n\n  compareScalar(diffs, 'key', a.key, b.key, {\n    breaking: true,\n    label: 'Key',\n  });\n  compareScalar(diffs, 'version', a.version, b.version, {\n    breaking: true,\n    label: 'Version',\n  });\n  compareScalar(diffs, 'kind', a.kind, b.kind, {\n    breaking: true,\n    label: 'Kind',\n  });\n\n  compareScalar(diffs, 'stability', a.stability, b.stability, {\n    breaking: isStabilityDowngrade(a, b),\n    label: 'Stability',\n  });\n\n  compareArray(diffs, 'owners', a.owners ?? [], b.owners ?? [], {\n    label: 'Owners',\n  });\n  compareArray(diffs, 'tags', a.tags ?? [], b.tags ?? [], { label: 'Tags' });\n\n  compareStructuralHints(diffs, a, b);\n\n  const filtered = options.breakingOnly\n    ? diffs.filter((d) => d.type === 'breaking')\n    : diffs;\n\n  return filtered;\n}\n\nfunction compareScalar(\n  diffs: SemanticDiffItem[],\n  path: string,\n  a: unknown,\n  b: unknown,\n  config: { breaking: boolean; label: string }\n) {\n  if (a === b) return;\n  diffs.push({\n    type: config.breaking ? 'breaking' : 'changed',\n    path,\n    oldValue: a,\n    newValue: b,\n    description: `${config.label} changed`,\n  });\n}\n\nfunction compareArray(\n  diffs: SemanticDiffItem[],\n  path: string,\n  a: string[],\n  b: string[],\n  config: { label: string }\n) {\n  const aSorted = [...a].sort();\n  const bSorted = [...b].sort();\n  if (JSON.stringify(aSorted) === JSON.stringify(bSorted)) return;\n\n  diffs.push({\n    type: 'changed',\n    path,\n    oldValue: aSorted,\n    newValue: bSorted,\n    description: `${config.label} changed`,\n  });\n}\n\nfunction isStabilityDowngrade(a: SpecScanResult, b: SpecScanResult): boolean {\n  const order: Record<string, number> = {\n    experimental: 0,\n    beta: 1,\n    stable: 2,\n    deprecated: 3,\n  };\n  const aValue = a.stability ? (order[a.stability] ?? 0) : 0;\n  const bValue = b.stability ? (order[b.stability] ?? 0) : 0;\n  // Moving toward deprecated is effectively a breaking signal for consumers.\n  return bValue > aValue;\n}\n\nfunction compareStructuralHints(\n  diffs: SemanticDiffItem[],\n  a: SpecScanResult,\n  b: SpecScanResult\n) {\n  // For operations these sections are usually required; missing them is breaking.\n  compareScalar(diffs, 'hasMeta', a.hasMeta, b.hasMeta, {\n    breaking: a.specType === 'operation' || b.specType === 'operation',\n    label: 'meta section presence',\n  });\n  compareScalar(diffs, 'hasIo', a.hasIo, b.hasIo, {\n    breaking: a.specType === 'operation' || b.specType === 'operation',\n    label: 'io section presence',\n  });\n  compareScalar(diffs, 'hasPolicy', a.hasPolicy, b.hasPolicy, {\n    breaking: a.specType === 'operation' || b.specType === 'operation',\n    label: 'policy section presence',\n  });\n  compareScalar(diffs, 'hasPayload', a.hasPayload, b.hasPayload, {\n    breaking: a.specType === 'event' || b.specType === 'event',\n    label: 'payload section presence',\n  });\n  compareScalar(diffs, 'hasContent', a.hasContent, b.hasContent, {\n    breaking: a.specType === 'presentation' || b.specType === 'presentation',\n    label: 'content section presence',\n  });\n  compareScalar(diffs, 'hasDefinition', a.hasDefinition, b.hasDefinition, {\n    breaking: a.specType === 'workflow' || b.specType === 'workflow',\n    label: 'definition section presence',\n  });\n}\n"],"mappings":";;;;;;AAeA,SAAgB,oBACd,OACA,OACA,OACA,OACA,UAA+B,EAAE,EACb;CACpB,MAAM,IAAI,eAAe,OAAO,MAAM;CACtC,MAAM,IAAI,eAAe,OAAO,MAAM;CAEtC,MAAMA,QAA4B,EAAE;AAEpC,eAAc,OAAO,YAAY,EAAE,UAAU,EAAE,UAAU;EACvD,UAAU;EACV,OAAO;EACR,CAAC;AAEF,eAAc,OAAO,OAAO,EAAE,KAAK,EAAE,KAAK;EACxC,UAAU;EACV,OAAO;EACR,CAAC;AACF,eAAc,OAAO,WAAW,EAAE,SAAS,EAAE,SAAS;EACpD,UAAU;EACV,OAAO;EACR,CAAC;AACF,eAAc,OAAO,QAAQ,EAAE,MAAM,EAAE,MAAM;EAC3C,UAAU;EACV,OAAO;EACR,CAAC;AAEF,eAAc,OAAO,aAAa,EAAE,WAAW,EAAE,WAAW;EAC1D,UAAU,qBAAqB,GAAG,EAAE;EACpC,OAAO;EACR,CAAC;AAEF,cAAa,OAAO,UAAU,EAAE,UAAU,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,EAC5D,OAAO,UACR,CAAC;AACF,cAAa,OAAO,QAAQ,EAAE,QAAQ,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,OAAO,QAAQ,CAAC;AAE1E,wBAAuB,OAAO,GAAG,EAAE;AAMnC,QAJiB,QAAQ,eACrB,MAAM,QAAQ,MAAM,EAAE,SAAS,WAAW,GAC1C;;AAKN,SAAS,cACP,OACA,MACA,GACA,GACA,QACA;AACA,KAAI,MAAM,EAAG;AACb,OAAM,KAAK;EACT,MAAM,OAAO,WAAW,aAAa;EACrC;EACA,UAAU;EACV,UAAU;EACV,aAAa,GAAG,OAAO,MAAM;EAC9B,CAAC;;AAGJ,SAAS,aACP,OACA,MACA,GACA,GACA,QACA;CACA,MAAM,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM;CAC7B,MAAM,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM;AAC7B,KAAI,KAAK,UAAU,QAAQ,KAAK,KAAK,UAAU,QAAQ,CAAE;AAEzD,OAAM,KAAK;EACT,MAAM;EACN;EACA,UAAU;EACV,UAAU;EACV,aAAa,GAAG,OAAO,MAAM;EAC9B,CAAC;;AAGJ,SAAS,qBAAqB,GAAmB,GAA4B;CAC3E,MAAMC,QAAgC;EACpC,cAAc;EACd,MAAM;EACN,QAAQ;EACR,YAAY;EACb;CACD,MAAM,SAAS,EAAE,YAAa,MAAM,EAAE,cAAc,IAAK;AAGzD,SAFe,EAAE,YAAa,MAAM,EAAE,cAAc,IAAK,KAEzC;;AAGlB,SAAS,uBACP,OACA,GACA,GACA;AAEA,eAAc,OAAO,WAAW,EAAE,SAAS,EAAE,SAAS;EACpD,UAAU,EAAE,aAAa,eAAe,EAAE,aAAa;EACvD,OAAO;EACR,CAAC;AACF,eAAc,OAAO,SAAS,EAAE,OAAO,EAAE,OAAO;EAC9C,UAAU,EAAE,aAAa,eAAe,EAAE,aAAa;EACvD,OAAO;EACR,CAAC;AACF,eAAc,OAAO,aAAa,EAAE,WAAW,EAAE,WAAW;EAC1D,UAAU,EAAE,aAAa,eAAe,EAAE,aAAa;EACvD,OAAO;EACR,CAAC;AACF,eAAc,OAAO,cAAc,EAAE,YAAY,EAAE,YAAY;EAC7D,UAAU,EAAE,aAAa,WAAW,EAAE,aAAa;EACnD,OAAO;EACR,CAAC;AACF,eAAc,OAAO,cAAc,EAAE,YAAY,EAAE,YAAY;EAC7D,UAAU,EAAE,aAAa,kBAAkB,EAAE,aAAa;EAC1D,OAAO;EACR,CAAC;AACF,eAAc,OAAO,iBAAiB,EAAE,eAAe,EAAE,eAAe;EACtE,UAAU,EAAE,aAAa,cAAc,EAAE,aAAa;EACtD,OAAO;EACR,CAAC"}

package/dist/analysis/feature-scan.d.ts

@@ -0,0 +1,15 @@
+import { FeatureScanResult } from "../types/analysis-types.js";
+
+//#region src/analysis/feature-scan.d.ts
+
+/**
+ * Check if a file is a feature file based on naming conventions.
+ */
+declare function isFeatureFile(filePath: string): boolean;
+/**
+ * Scan a feature source file to extract metadata.
+ */
+declare function scanFeatureSource(code: string, filePath: string): FeatureScanResult;
+//#endregion
+export { isFeatureFile, scanFeatureSource };
+//# sourceMappingURL=feature-scan.d.ts.map

package/dist/analysis/feature-scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-scan.d.ts","names":[],"sources":["../../src/analysis/feature-scan.ts"],"sourcesContent":[],"mappings":";;;;;;;iBAYgB,aAAA;;;;iBAOA,iBAAA,kCAGb"}

package/dist/analysis/feature-scan.js

@@ -0,0 +1,152 @@
+//#region src/analysis/feature-scan.ts
+/**
+* Check if a file is a feature file based on naming conventions.
+*/
+function isFeatureFile(filePath) {
+	return filePath.includes(".feature.");
+}
+/**
+* Scan a feature source file to extract metadata.
+*/
+function scanFeatureSource(code, filePath) {
+	const key = matchStringField(code, "key") ?? extractKeyFromFilePath(filePath);
+	const title = matchStringField(code, "title") ?? void 0;
+	const description = matchStringField(code, "description") ?? void 0;
+	const domain = matchStringField(code, "domain") ?? void 0;
+	const stabilityRaw = matchStringField(code, "stability");
+	return {
+		filePath,
+		key,
+		title,
+		description,
+		domain,
+		stability: isStability(stabilityRaw) ? stabilityRaw : void 0,
+		owners: matchStringArrayField(code, "owners"),
+		tags: matchStringArrayField(code, "tags"),
+		operations: extractRefsFromArray(code, "operations"),
+		events: extractRefsFromArray(code, "events"),
+		presentations: extractRefsFromArray(code, "presentations"),
+		experiments: extractRefsFromArray(code, "experiments"),
+		capabilities: extractCapabilities(code),
+		opToPresentationLinks: extractOpToPresentationLinks(code)
+	};
+}
+/**
+* Extract refs from a named array (e.g., operations, events, presentations).
+*/
+function extractRefsFromArray(code, fieldName) {
+	const refs = [];
+	const arrayPattern = new RegExp(`${escapeRegex(fieldName)}\\s*:\\s*\\[([\\s\\S]*?)\\]`, "m");
+	const arrayMatch = code.match(arrayPattern);
+	if (!arrayMatch?.[1]) return refs;
+	const refPattern = /\{\s*key:\s*['"]([^'"]+)['"]\s*,\s*version:\s*(\d+)/g;
+	let match;
+	while ((match = refPattern.exec(arrayMatch[1])) !== null) if (match[1] && match[2]) refs.push({
+		key: match[1],
+		version: Number(match[2])
+	});
+	return refs;
+}
+/**
+* Extract capability bindings (provides and requires).
+*/
+function extractCapabilities(code) {
+	const provides = [];
+	const requires = [];
+	const capabilitiesMatch = code.match(/capabilities\s*:\s*\{([\s\S]*?)\}/);
+	if (!capabilitiesMatch?.[1]) return {
+		provides,
+		requires
+	};
+	const capabilitiesContent = capabilitiesMatch[1];
+	const providesMatch = capabilitiesContent.match(/provides\s*:\s*\[([\s\S]*?)\]/);
+	if (providesMatch?.[1]) {
+		const refPattern = /\{\s*key:\s*['"]([^'"]+)['"]\s*,\s*version:\s*(\d+)/g;
+		let match;
+		while ((match = refPattern.exec(providesMatch[1])) !== null) if (match[1] && match[2]) provides.push({
+			key: match[1],
+			version: Number(match[2])
+		});
+	}
+	const requiresMatch = capabilitiesContent.match(/requires\s*:\s*\[([\s\S]*?)\]/);
+	if (requiresMatch?.[1]) {
+		const refPatternWithVersion = /\{\s*key:\s*['"]([^'"]+)['"]\s*,\s*version:\s*(\d+)/g;
+		const refPatternKeyOnly = /\{\s*key:\s*['"]([^'"]+)['"]\s*\}/g;
+		let match = null;
+		while ((match = refPatternWithVersion.exec(requiresMatch[1])) !== null) if (match[1] && match[2]) requires.push({
+			key: match[1],
+			version: Number(match[2])
+		});
+		while ((match = refPatternKeyOnly.exec(requiresMatch[1])) !== null) if (match && match[1]) {
+			if (!requires.some((r) => r.key === match[1])) requires.push({
+				key: match[1],
+				version: 1
+			});
+		}
+	}
+	return {
+		provides,
+		requires
+	};
+}
+/**
+* Extract opToPresentation links.
+*/
+function extractOpToPresentationLinks(code) {
+	const links = [];
+	const arrayMatch = code.match(/opToPresentation\s*:\s*\[([\s\S]*?)\]/);
+	if (!arrayMatch?.[1]) return links;
+	const linkPattern = /\{\s*op:\s*\{\s*key:\s*['"]([^'"]+)['"]\s*,\s*version:\s*(\d+)\s*\}\s*,\s*pres:\s*\{\s*key:\s*['"]([^'"]+)['"]\s*,\s*version:\s*(\d+)\s*\}/g;
+	let match;
+	while ((match = linkPattern.exec(arrayMatch[1])) !== null) if (match[1] && match[2] && match[3] && match[4]) links.push({
+		op: {
+			key: match[1],
+			version: Number(match[2])
+		},
+		pres: {
+			key: match[3],
+			version: Number(match[4])
+		}
+	});
+	return links;
+}
+/**
+* Extract key from file path as fallback.
+*/
+function extractKeyFromFilePath(filePath) {
+	return (filePath.split("/").pop() ?? filePath).replace(/\.feature\.[jt]s$/, "").replace(/[^a-zA-Z0-9-]/g, "-");
+}
+/**
+* Match a string field in source code.
+*/
+function matchStringField(code, field) {
+	const regex = /* @__PURE__ */ new RegExp(`${escapeRegex(field)}\\s*:\\s*['"]([^'"]+)['"]`);
+	return code.match(regex)?.[1] ?? null;
+}
+/**
+* Match a string array field in source code.
+*/
+function matchStringArrayField(code, field) {
+	const regex = /* @__PURE__ */ new RegExp(`${escapeRegex(field)}\\s*:\\s*\\[([\\s\\S]*?)\\]`);
+	const match = code.match(regex);
+	if (!match?.[1]) return void 0;
+	const inner = match[1];
+	const items = Array.from(inner.matchAll(/['"]([^'"]+)['"]/g)).map((m) => m[1]).filter((value) => typeof value === "string" && value.length > 0);
+	return items.length > 0 ? items : void 0;
+}
+/**
+* Check if a value is a valid stability.
+*/
+function isStability(value) {
+	return value === "experimental" || value === "beta" || value === "stable" || value === "deprecated";
+}
+/**
+* Escape regex special characters.
+*/
+function escapeRegex(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+//#endregion
+export { isFeatureFile, scanFeatureSource };
+//# sourceMappingURL=feature-scan.js.map

package/dist/analysis/feature-scan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-scan.js","names":["refs: RefInfo[]","provides: RefInfo[]","requires: RefInfo[]","match: RegExpExecArray | null","links: { op: RefInfo; pres: RefInfo }[]"],"sources":["../../src/analysis/feature-scan.ts"],"sourcesContent":["/**\n * Feature file scanning utilities.\n *\n * Extracts FeatureModuleSpec metadata from source code without execution.\n */\n\nimport type { FeatureScanResult, RefInfo } from '../types/analysis-types';\nimport type { Stability } from '../types/spec-types';\n\n/**\n * Check if a file is a feature file based on naming conventions.\n */\nexport function isFeatureFile(filePath: string): boolean {\n  return filePath.includes('.feature.');\n}\n\n/**\n * Scan a feature source file to extract metadata.\n */\nexport function scanFeatureSource(\n  code: string,\n  filePath: string\n): FeatureScanResult {\n  const key = matchStringField(code, 'key') ?? extractKeyFromFilePath(filePath);\n  const title = matchStringField(code, 'title') ?? undefined;\n  const description = matchStringField(code, 'description') ?? undefined;\n  const domain = matchStringField(code, 'domain') ?? undefined;\n  const stabilityRaw = matchStringField(code, 'stability');\n  const stability = isStability(stabilityRaw) ? stabilityRaw : undefined;\n  const owners = matchStringArrayField(code, 'owners');\n  const tags = matchStringArrayField(code, 'tags');\n\n  // Extract operations\n  const operations = extractRefsFromArray(code, 'operations');\n\n  // Extract events\n  const events = extractRefsFromArray(code, 'events');\n\n  // Extract presentations\n  const presentations = extractRefsFromArray(code, 'presentations');\n\n  // Extract experiments\n  const experiments = extractRefsFromArray(code, 'experiments');\n\n  // Extract capabilities\n  const capabilities = extractCapabilities(code);\n\n  // Extract op to presentation links\n  const opToPresentationLinks = extractOpToPresentationLinks(code);\n\n  return {\n    filePath,\n    key,\n    title,\n    description,\n    domain,\n    stability,\n    owners,\n    tags,\n    operations,\n    events,\n    presentations,\n    experiments,\n    capabilities,\n    opToPresentationLinks,\n  };\n}\n\n/**\n * Extract refs from a named array (e.g., operations, events, presentations).\n */\nfunction extractRefsFromArray(code: string, fieldName: string): RefInfo[] {\n  const refs: RefInfo[] = [];\n\n  // Match the array section\n  const arrayPattern = new RegExp(\n    `${escapeRegex(fieldName)}\\\\s*:\\\\s*\\\\[([\\\\s\\\\S]*?)\\\\]`,\n    'm'\n  );\n  const arrayMatch = code.match(arrayPattern);\n\n  if (!arrayMatch?.[1]) return refs;\n\n  // Extract each { key: 'x', version: N } entry\n  const refPattern = /\\{\\s*key:\\s*['\"]([^'\"]+)['\"]\\s*,\\s*version:\\s*(\\d+)/g;\n  let match;\n  while ((match = refPattern.exec(arrayMatch[1])) !== null) {\n    if (match[1] && match[2]) {\n      refs.push({\n        key: match[1],\n        version: Number(match[2]),\n      });\n    }\n  }\n\n  return refs;\n}\n\n/**\n * Extract capability bindings (provides and requires).\n */\nfunction extractCapabilities(code: string): {\n  provides: RefInfo[];\n  requires: RefInfo[];\n} {\n  const provides: RefInfo[] = [];\n  const requires: RefInfo[] = [];\n\n  // Match the capabilities section\n  const capabilitiesMatch = code.match(/capabilities\\s*:\\s*\\{([\\s\\S]*?)\\}/);\n  if (!capabilitiesMatch?.[1]) {\n    return { provides, requires };\n  }\n\n  const capabilitiesContent = capabilitiesMatch[1];\n\n  // Extract provides\n  const providesMatch = capabilitiesContent.match(\n    /provides\\s*:\\s*\\[([\\s\\S]*?)\\]/\n  );\n  if (providesMatch?.[1]) {\n    const refPattern = /\\{\\s*key:\\s*['\"]([^'\"]+)['\"]\\s*,\\s*version:\\s*(\\d+)/g;\n    let match;\n    while ((match = refPattern.exec(providesMatch[1])) !== null) {\n      if (match[1] && match[2]) {\n        provides.push({\n          key: match[1],\n          version: Number(match[2]),\n        });\n      }\n    }\n  }\n\n  // Extract requires\n  const requiresMatch = capabilitiesContent.match(\n    /requires\\s*:\\s*\\[([\\s\\S]*?)\\]/\n  );\n  if (requiresMatch?.[1]) {\n    // Requires can have key+version or just key\n    const refPatternWithVersion =\n      /\\{\\s*key:\\s*['\"]([^'\"]+)['\"]\\s*,\\s*version:\\s*(\\d+)/g;\n    const refPatternKeyOnly = /\\{\\s*key:\\s*['\"]([^'\"]+)['\"]\\s*\\}/g;\n\n    let match: RegExpExecArray | null = null;\n    while ((match = refPatternWithVersion.exec(requiresMatch[1])) !== null) {\n      if (match[1] && match[2]) {\n        requires.push({\n          key: match[1],\n          version: Number(match[2]),\n        });\n      }\n    }\n\n    // Also match key-only requires (version defaults to 1)\n    while ((match = refPatternKeyOnly.exec(requiresMatch[1])) !== null) {\n      if (match && match[1]) {\n        // Check if we already added this with a version\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        const alreadyExists = requires.some((r) => r.key === match![1]);\n        if (!alreadyExists) {\n          requires.push({\n            key: match[1],\n            version: 1, // Default version\n          });\n        }\n      }\n    }\n  }\n\n  return { provides, requires };\n}\n\n/**\n * Extract opToPresentation links.\n */\nfunction extractOpToPresentationLinks(\n  code: string\n): { op: RefInfo; pres: RefInfo }[] {\n  const links: { op: RefInfo; pres: RefInfo }[] = [];\n\n  // Match the opToPresentation array\n  const arrayMatch = code.match(/opToPresentation\\s*:\\s*\\[([\\s\\S]*?)\\]/);\n  if (!arrayMatch?.[1]) return links;\n\n  // Match each link entry\n  // Pattern: { op: { key: 'x', version: N }, pres: { key: 'y', version: M } }\n  const linkPattern =\n    /\\{\\s*op:\\s*\\{\\s*key:\\s*['\"]([^'\"]+)['\"]\\s*,\\s*version:\\s*(\\d+)\\s*\\}\\s*,\\s*pres:\\s*\\{\\s*key:\\s*['\"]([^'\"]+)['\"]\\s*,\\s*version:\\s*(\\d+)\\s*\\}/g;\n\n  let match;\n  while ((match = linkPattern.exec(arrayMatch[1])) !== null) {\n    if (match[1] && match[2] && match[3] && match[4]) {\n      links.push({\n        op: { key: match[1], version: Number(match[2]) },\n        pres: { key: match[3], version: Number(match[4]) },\n      });\n    }\n  }\n\n  return links;\n}\n\n/**\n * Extract key from file path as fallback.\n */\nfunction extractKeyFromFilePath(filePath: string): string {\n  const fileName = filePath.split('/').pop() ?? filePath;\n  return fileName\n    .replace(/\\.feature\\.[jt]s$/, '')\n    .replace(/[^a-zA-Z0-9-]/g, '-');\n}\n\n/**\n * Match a string field in source code.\n */\nfunction matchStringField(code: string, field: string): string | null {\n  const regex = new RegExp(`${escapeRegex(field)}\\\\s*:\\\\s*['\"]([^'\"]+)['\"]`);\n  const match = code.match(regex);\n  return match?.[1] ?? null;\n}\n\n/**\n * Match a string array field in source code.\n */\nfunction matchStringArrayField(\n  code: string,\n  field: string\n): string[] | undefined {\n  const regex = new RegExp(`${escapeRegex(field)}\\\\s*:\\\\s*\\\\[([\\\\s\\\\S]*?)\\\\]`);\n  const match = code.match(regex);\n  if (!match?.[1]) return undefined;\n\n  const inner = match[1];\n  const items = Array.from(inner.matchAll(/['\"]([^'\"]+)['\"]/g))\n    .map((m) => m[1])\n    .filter(\n      (value): value is string => typeof value === 'string' && value.length > 0\n    );\n\n  return items.length > 0 ? items : undefined;\n}\n\n/**\n * Check if a value is a valid stability.\n */\nfunction isStability(value: string | null): value is Stability {\n  return (\n    value === 'experimental' ||\n    value === 'beta' ||\n    value === 'stable' ||\n    value === 'deprecated'\n  );\n}\n\n/**\n * Escape regex special characters.\n */\nfunction escapeRegex(value: string): string {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n"],"mappings":"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"}

package/dist/analysis/grouping.d.ts

@@ -0,0 +1,79 @@
+import { Stability } from "../types/spec-types.js";
+import { FeatureScanResult, SpecScanResult } from "../types/analysis-types.js";
+
+//#region src/analysis/grouping.d.ts
+
+/**
+ * Filter criteria for spec scan results.
+ */
+interface SpecFilter {
+  /** Filter by tags (item must have at least one matching tag) */
+  tags?: string[];
+  /** Filter by owners (item must have at least one matching owner) */
+  owners?: string[];
+  /** Filter by stability levels */
+  stability?: Stability[];
+  /** Filter by spec type */
+  specType?: SpecScanResult['specType'][];
+  /** Filter by name pattern (glob) */
+  namePattern?: string;
+}
+/**
+ * Grouping key function type.
+ */
+type GroupKeyFn<T> = (item: T) => string;
+/**
+ * Grouped items result.
+ */
+interface GroupedItems<T> {
+  key: string;
+  items: T[];
+}
+/**
+ * Pre-built grouping strategies for spec scan results.
+ */
+declare const SpecGroupingStrategies: {
+  /** Group by first tag. */
+  byTag: (item: SpecScanResult) => string;
+  /** Group by first owner. */
+  byOwner: (item: SpecScanResult) => string;
+  /** Group by domain (first segment of name). */
+  byDomain: (item: SpecScanResult) => string;
+  /** Group by stability. */
+  byStability: (item: SpecScanResult) => string;
+  /** Group by spec type. */
+  bySpecType: (item: SpecScanResult) => string;
+  /** Group by file directory. */
+  byDirectory: (item: SpecScanResult) => string;
+};
+/**
+ * Filter specs by criteria.
+ */
+declare function filterSpecs(specs: SpecScanResult[], filter: SpecFilter): SpecScanResult[];
+/**
+ * Group specs by key function.
+ */
+declare function groupSpecs<T>(items: T[], keyFn: GroupKeyFn<T>): Map<string, T[]>;
+/**
+ * Group specs and return as array.
+ */
+declare function groupSpecsToArray<T>(items: T[], keyFn: GroupKeyFn<T>): GroupedItems<T>[];
+/**
+ * Get unique tags from spec results.
+ */
+declare function getUniqueSpecTags(specs: SpecScanResult[]): string[];
+/**
+ * Get unique owners from spec results.
+ */
+declare function getUniqueSpecOwners(specs: SpecScanResult[]): string[];
+/**
+ * Get unique domains from spec results.
+ */
+declare function getUniqueSpecDomains(specs: SpecScanResult[]): string[];
+/**
+ * Filter features by criteria.
+ */
+declare function filterFeatures(features: FeatureScanResult[], filter: SpecFilter): FeatureScanResult[];
+//#endregion
+export { GroupKeyFn, GroupedItems, SpecFilter, SpecGroupingStrategies, filterFeatures, filterSpecs, getUniqueSpecDomains, getUniqueSpecOwners, getUniqueSpecTags, groupSpecs, groupSpecsToArray };
+//# sourceMappingURL=grouping.d.ts.map

package/dist/analysis/grouping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grouping.d.ts","names":[],"sources":["../../src/analysis/grouping.ts"],"sourcesContent":[],"mappings":";;;;;AAmCA;AAQA;;AAKkB,UAlCD,UAAA,CAkCC;EAGC;EASG,IAAA,CAAA,EAAA,MAAA,EAAA;EAGD;EAGC,MAAA,CAAA,EAAA,MAAA,EAAA;EAAc;EAUpB,SAAA,CAAA,EAxDF,SAwDa,EAAA;EAClB;EACC,QAAA,CAAA,EAxDG,cAwDH,CAAA,UAAA,CAAA,EAAA;EACP;EAAc,WAAA,CAAA,EAAA,MAAA;AAiDjB;;;;AAGe,KArGH,UAqGG,CAAA,CAAA,CAAA,GAAA,CAAA,IAAA,EArGoB,CAqGpB,EAAA,GAAA,MAAA;;;AAmBf;AACS,UApHQ,YAoHR,CAAA,CAAA,CAAA,CAAA;EACW,GAAA,EAAA,MAAA;EAAX,KAAA,EAnHA,CAmHA,EAAA;;;;AAWT;AAagB,cArIH,sBAqI8B,EAAA;EAa3B;EAWA,KAAA,EAAA,CAAA,IAAA,EA3JA,cA2Jc,EAAA,GAAA,MAAA;EAClB;EACF,OAAA,EAAA,CAAA,IAAA,EA1JQ,cA0JR,EAAA,GAAA,MAAA;EACP;EAAiB,QAAA,EAAA,CAAA,IAAA,EAxJD,cAwJC,EAAA,GAAA,MAAA;;sBA/IE;;qBAGD;;sBAGC;;;;;iBAUN,WAAA,QACP,0BACC,aACP;;;;iBAiDa,qBACP,YACA,WAAW,KACjB,YAAY;;;;iBAmBC,4BACP,YACA,WAAW,KACjB,aAAa;;;;iBAUA,iBAAA,QAAyB;;;;iBAazB,mBAAA,QAA2B;;;;iBAa3B,oBAAA,QAA4B;;;;iBAW5B,cAAA,WACJ,6BACF,aACP"}

package/dist/analysis/grouping.js

@@ -0,0 +1,115 @@
+//#region src/analysis/grouping.ts
+/**
+* Pre-built grouping strategies for spec scan results.
+*/
+const SpecGroupingStrategies = {
+	byTag: (item) => item.tags?.[0] ?? "untagged",
+	byOwner: (item) => item.owners?.[0] ?? "unowned",
+	byDomain: (item) => {
+		const key = item.key ?? "";
+		if (key.includes(".")) return key.split(".")[0] ?? "default";
+		return "default";
+	},
+	byStability: (item) => item.stability ?? "stable",
+	bySpecType: (item) => item.specType,
+	byDirectory: (item) => {
+		return item.filePath.split("/").slice(0, -1).join("/") || ".";
+	}
+};
+/**
+* Filter specs by criteria.
+*/
+function filterSpecs(specs, filter) {
+	return specs.filter((spec) => {
+		if (filter.tags?.length) {
+			if (!filter.tags.some((tag) => spec.tags?.includes(tag))) return false;
+		}
+		if (filter.owners?.length) {
+			if (!filter.owners.some((owner) => spec.owners?.includes(owner))) return false;
+		}
+		if (filter.stability?.length) {
+			if (!filter.stability.includes(spec.stability ?? "stable")) return false;
+		}
+		if (filter.specType?.length) {
+			if (!filter.specType.includes(spec.specType)) return false;
+		}
+		if (filter.namePattern) {
+			const key = spec.key ?? "";
+			const pattern = filter.namePattern.replace(/\*/g, ".*").replace(/\?/g, ".");
+			if (!new RegExp(`^${pattern}$`, "i").test(key)) return false;
+		}
+		return true;
+	});
+}
+/**
+* Group specs by key function.
+*/
+function groupSpecs(items, keyFn) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const key = keyFn(item);
+		const existing = groups.get(key);
+		if (existing) existing.push(item);
+		else groups.set(key, [item]);
+	}
+	return groups;
+}
+/**
+* Group specs and return as array.
+*/
+function groupSpecsToArray(items, keyFn) {
+	const map = groupSpecs(items, keyFn);
+	return Array.from(map.entries()).map(([key, items$1]) => ({
+		key,
+		items: items$1
+	})).sort((a, b) => a.key.localeCompare(b.key));
+}
+/**
+* Get unique tags from spec results.
+*/
+function getUniqueSpecTags(specs) {
+	const tags = /* @__PURE__ */ new Set();
+	for (const spec of specs) for (const tag of spec.tags ?? []) tags.add(tag);
+	return Array.from(tags).sort();
+}
+/**
+* Get unique owners from spec results.
+*/
+function getUniqueSpecOwners(specs) {
+	const owners = /* @__PURE__ */ new Set();
+	for (const spec of specs) for (const owner of spec.owners ?? []) owners.add(owner);
+	return Array.from(owners).sort();
+}
+/**
+* Get unique domains from spec results.
+*/
+function getUniqueSpecDomains(specs) {
+	const domains = /* @__PURE__ */ new Set();
+	for (const spec of specs) domains.add(SpecGroupingStrategies.byDomain(spec));
+	return Array.from(domains).sort();
+}
+/**
+* Filter features by criteria.
+*/
+function filterFeatures(features, filter) {
+	return features.filter((feature) => {
+		if (filter.tags?.length) {
+			if (!filter.tags.some((tag) => feature.tags?.includes(tag))) return false;
+		}
+		if (filter.owners?.length) {
+			if (!filter.owners.some((owner) => feature.owners?.includes(owner))) return false;
+		}
+		if (filter.stability?.length) {
+			if (!filter.stability.includes(feature.stability ?? "stable")) return false;
+		}
+		if (filter.namePattern) {
+			const pattern = filter.namePattern.replace(/\*/g, ".*").replace(/\?/g, ".");
+			if (!new RegExp(`^${pattern}$`, "i").test(feature.key)) return false;
+		}
+		return true;
+	});
+}
+
+//#endregion
+export { SpecGroupingStrategies, filterFeatures, filterSpecs, getUniqueSpecDomains, getUniqueSpecOwners, getUniqueSpecTags, groupSpecs, groupSpecsToArray };
+//# sourceMappingURL=grouping.js.map