@r_masseater/msch 0.0.0-stage → 0.2.0

package/dist/cli.mjs

@@ -0,0 +1,1229 @@
+#!/usr/bin/env node
+import { $ as isSignatureDeclaration, A as API, B as isCallExpression, C as MANIFEST_FILE, D as workspaceDependencies, E as readManifest, F as getLeadingCommentRanges, G as isInterfaceDeclaration, H as isElementAccessExpression, I as getNameOfDeclaration, J as isNewExpression, K as isModuleBlock, L as getTextOfJSDocComment, M as InternalSymbolName, N as SyntaxKind, O as RepositoryFiles, P as getJSDocTags, Q as isPropertyAssignment, R as isArrayLiteralExpression, S as uniqueByReference, T as dependencyEntries, U as isEnumDeclaration, V as isClassDeclaration, W as isIdentifier, X as isObjectLiteralExpression, Y as isNumericLiteral, Z as isPropertyAccessExpression, _ as lineOf, a as problemAt, at as isUnionTypeNode, b as resolvedSymbol, c as childrenOf, ct as isVariableStatement, d as declarationsOf, et as isSourceFile, f as descendantsOf, g as isTypeDeclaration, h as isGenericDeclaration, i as formatProblem, it as isTypeReferenceNode, j as IndexKind, k as nodeRepositoryFiles, l as columnOf, m as isExternalDeclaration, n as ProblemList, nt as isTypeAliasDeclaration, o as sortProblems, ot as isVariableDeclaration, p as importedModulesOf, q as isModuleDeclaration, rt as isTypeLiteralNode, s as NODE_MODULES_SEGMENT, st as isVariableDeclarationList, tt as isStringLiteral, u as contains, v as propertyNamesOf, w as NODE_MODULES, x as symbolAt, y as referencedSymbols, z as isBinaryExpression } from "./cli-contract-BRpk_UKr.mjs";
+import { Array, Cause, Effect, FileSystem, Function, Layer, Number as Number$1, Option, Order, Path, Record, Schema, Stdio, Stream, String as String$1, pipe } from "effect";
+import { layer } from "@effect/platform-node/NodeServices";
+import { ChildProcess } from "effect/process";
+import { LineCounter, isMap, isScalar, parseAllDocuments, parseDocument } from "yaml";
+import { runMain } from "@effect/platform-node/NodeRuntime";
+import { FetchHttpClient } from "effect/http";
+import { Otlp, OtlpSerialization } from "effect/observability";
+// src/slots.ts
+const ANNOTATED_KINDS = /* @__PURE__ */ new Set([
+	SyntaxKind.Parameter,
+	SyntaxKind.VariableDeclaration,
+	SyntaxKind.PropertySignature,
+	SyntaxKind.PropertyDeclaration
+]);
+const isAnnotated = (declaration) => ANNOTATED_KINDS.has(declaration.kind);
+const annotationOf = (declaration) => Option.liftPredicate(declaration, isAnnotated).pipe(Option.flatMap((annotated) => Option.fromUndefinedOr(annotated.type)));
+const argumentSlot = (checker) => (expression) => {
+	const call = expression.parent;
+	if (!isCallExpression(call) && !isNewExpression(call)) return Option.none();
+	const { arguments: listed } = call;
+	const index = (listed ?? []).indexOf(expression);
+	return Option.fromUndefinedOr(checker.getResolvedSignature(call).declaration).pipe(Option.flatMap((handle) => Option.fromUndefinedOr(handle.resolve())), Option.filter(isSignatureDeclaration), Option.flatMap((declaration) => Array.get(declaration.parameters, index)));
+};
+const propertySlot = (checker) => (expression) => {
+	const assignment = expression.parent;
+	if (!isPropertyAssignment(assignment) || !isObjectLiteralExpression(assignment.parent)) return Option.none();
+	return Option.fromUndefinedOr(checker.getContextualType(assignment.parent)).pipe(Option.flatMap((objectType) => Option.fromUndefinedOr(objectType.getProperty(assignment.name.getText()))), Option.flatMap((property) => Array.head(declarationsOf(property))));
+};
+const variableSlot = (expression) => {
+	const declaration = expression.parent;
+	if (!isVariableDeclaration(declaration) || declaration.initializer !== expression) return Option.none();
+	return Option.some(declaration);
+};
+const slotOf = (checker) => (expression) => argumentSlot(checker)(expression).pipe(Option.orElse(() => propertySlot(checker)(expression)), Option.orElse(() => variableSlot(expression)));
+const contextSymbolsOf = (checker) => (expression) => {
+	const alias = Option.fromUndefinedOr(checker.getContextualType(expression)).pipe(Option.flatMap((contextual) => Option.fromUndefinedOr(contextual.getAliasSymbol())));
+	if (Option.isSome(alias)) return [alias.value];
+	return slotOf(checker)(expression).pipe(Option.flatMap(annotationOf), Option.map((annotation) => referencedSymbols(checker)(annotation)), Option.getOrElse(() => []));
+};
+// src/values.ts
+const SCHEMA_TYPE_PROPERTIES = ["Type", "_output"];
+const MINIMUM_SET_SIZE = 2;
+const DATA_FIRST_ARITY = 2;
+const valueKey = (value) => `${typeof value}:${String(value)}`;
+const literalValueOf = (type) => {
+	if (type.isStringLiteralType() || type.isNumberLiteralType()) return Option.some(type.value);
+	return Option.none();
+};
+const literalValuesOf = (types) => {
+	const values = pipe(types, Array.map((member) => literalValueOf(member)), Array.getSomes, Array.dedupeWith((left, right) => valueKey(left) === valueKey(right)));
+	if (values.length !== types.length || values.length < MINIMUM_SET_SIZE) return Option.none();
+	return Option.some(values);
+};
+const literalUnionOf = (type) => {
+	if (!type.isUnionType()) return Option.none();
+	return literalValuesOf(type.getTypes());
+};
+const elementTypeOf = (checker, type) => {
+	if (!checker.isArrayLikeType(type)) return Option.none();
+	return Option.fromUndefinedOr(checker.getIndexTypeOfType(type, IndexKind.Number));
+};
+const schemaTypeOf = (checker) => (type) => Array.findFirst(SCHEMA_TYPE_PROPERTIES, (name) => Option.fromUndefinedOr(checker.getPropertyOfType(type, name))).pipe(Option.map((property) => checker.getTypeOfSymbol(property)));
+const finiteValuesOf = (checker) => (type) => literalUnionOf(type).pipe(Option.orElse(() => elementTypeOf(checker, type).pipe(Option.flatMap(literalUnionOf))), Option.orElse(() => schemaTypeOf(checker)(type).pipe(Option.flatMap(literalUnionOf))));
+const vocabularyOf = (checker) => (type) => {
+	if (!type.isUnionType()) return Option.none();
+	const optionalIds = /* @__PURE__ */ new Set([checker.getUndefinedType().id, checker.getNullType().id]);
+	const members = pipe(type.getTypes(), Array.filter((member) => !optionalIds.has(member.id)));
+	const values = Array.getSomes(pipe(members, Array.map((member) => literalValueOf(member))));
+	if (values.length < MINIMUM_SET_SIZE) return Option.none();
+	return Option.some({
+		values,
+		admitsUnnamedValues: values.length !== members.length
+	});
+};
+const isSubsetOf = Function.dual(DATA_FIRST_ARITY, (subset, superset) => {
+	const held = new Set(pipe(superset, Array.map((value) => valueKey(value))));
+	return pipe(subset, Array.every((value) => held.has(valueKey(value))));
+});
+const sameValues = Function.dual(DATA_FIRST_ARITY, (left, right) => left.length === right.length && isSubsetOf(left, right));
+const valueText = (value) => {
+	if (typeof value === "string") return `"${value}"`;
+	return String(value);
+};
+const formatValues = (values) => pipe(values, Array.map(valueText), Array.join(" | "));
+// src/flows.ts
+const SCOPE_PREFIX$1 = "@";
+const SCOPED_SEGMENTS = 2;
+const UNSCOPED_SEGMENTS = 1;
+const MODULE_PREFIX = /^".*?"\./u;
+const packageOf$1 = (fileName) => {
+	const afterModules = pipe(fileName, String$1.lastIndexOf(NODE_MODULES_SEGMENT), Option.match({
+		onNone: () => fileName,
+		onSome: (index) => String$1.slice(index + NODE_MODULES_SEGMENT.length)(fileName)
+	}));
+	const segments = String$1.split("/")(afterModules);
+	if (String$1.startsWith(SCOPE_PREFIX$1)(afterModules)) return pipe(Array.take(segments, SCOPED_SEGMENTS), Array.join("/"));
+	return pipe(Array.take(segments, UNSCOPED_SEGMENTS), Array.join("/"));
+};
+const externalDeclarationOf = (context) => (symbol) => Array.findFirst(declarationsOf(symbol), (declaration) => isExternalDeclaration(context.program)(declaration));
+const aliasTarget = (context) => (type) => Option.fromUndefinedOr(type.getAliasSymbol()).pipe(Option.flatMap((alias) => externalDeclarationOf(context)(alias).pipe(Option.map((declaration) => `${String$1.replace(MODULE_PREFIX, "")(context.checker.getFullyQualifiedName(alias))} from ${packageOf$1(declaration.getSourceFile().fileName)}`))));
+const isNamedContainer = (node) => isSignatureDeclaration(node) || isInterfaceDeclaration(node) || isClassDeclaration(node);
+const slotTarget = (context) => (expression) => slotOf(context.checker)(expression).pipe(Option.filter((slot) => isExternalDeclaration(context.program)(slot)), Option.filter((slot) => Option.isSome(vocabularyOf(context.checker)(context.checker.getTypeAtLocation(slot)))), Option.map((slot) => {
+	const owner = Option.liftPredicate(slot.parent, isNamedContainer).pipe(Option.flatMap((container) => Option.fromUndefinedOr(getNameOfDeclaration(container))), Option.map((name) => ` of ${name.getText()}`), Option.getOrElse(() => ""));
+	return `${Option.fromUndefinedOr(getNameOfDeclaration(slot)).pipe(Option.map((found) => found.getText()), Option.getOrElse(() => "value"))}${owner} from ${packageOf$1(slot.getSourceFile().fileName)}`;
+}));
+const libraryTargetOf = (context) => (expression, contextual) => aliasTarget(context)(contextual).pipe(Option.orElse(() => slotTarget(context)(expression)));
+const siteWithin = (context) => (node) => Array.findFirst(context.sites, (site) => contains(node)(site.node));
+const aliasSite = (context) => (type) => Option.fromUndefinedOr(type.getAliasSymbol()).pipe(Option.flatMap((alias) => Array.findFirst(declarationsOf(alias), isTypeAliasDeclaration)), Option.flatMap(siteWithin(context)));
+const annotationSite = (context) => (expression) => symbolAt(context.checker)(expression).pipe(Option.flatMap((symbol) => Option.fromUndefinedOr(symbol.valueDeclaration)), Option.flatMap((handle) => Option.fromUndefinedOr(handle.resolve())), Option.flatMap(annotationOf), Option.flatMap((annotation) => siteWithin(context)(annotation).pipe(Option.orElse(() => aliasSite(context)(context.checker.getTypeFromTypeNode(annotation))))));
+const siteBehind = (context) => (expression) => aliasSite(context)(context.checker.getTypeAtLocation(expression)).pipe(Option.orElse(() => annotationSite(context)(expression)));
+const isFlowSource = (node) => isIdentifier(node) || isPropertyAccessExpression(node) || isElementAccessExpression(node);
+const flowOf = (context) => (expression) => Option.fromUndefinedOr(context.checker.getContextualType(expression)).pipe(Option.flatMap((contextual) => Option.all([vocabularyOf(context.checker)(contextual), libraryTargetOf(context)(expression, contextual)])), Option.flatMap(([vocabulary, target]) => siteBehind(context)(expression).pipe(Option.filter((site) => isSubsetOf(site.values, vocabulary.values)), Option.map((site) => ({
+	site,
+	target
+})))));
+const flowsIn = (context) => (sourceFile) => Array.getSomes(pipe(descendantsOf(sourceFile), Array.filter((node) => isFlowSource(node)), Array.map((node) => flowOf(context)(node))));
+// src/owners.ts
+const OWNER_TAG = "msch";
+const FIRST_OWNER_COUNT = 1;
+const ownerKeyOf = (declaration) => {
+	if (!isVariableDeclaration(declaration) || !isIdentifier(declaration.name)) return Option.none();
+	return Option.some(`${declaration.getSourceFile().fileName}#${declaration.name.text}`);
+};
+const annotationsOf = (node) => pipe(getJSDocTags(node), Array.filter((tag) => tag.tagName.text === OWNER_TAG), Array.map((tag) => ({
+	node,
+	conceptId: String$1.trim(getTextOfJSDocComment(tag.comment) ?? "")
+})));
+const ANNOTATABLE_KINDS = /* @__PURE__ */ new Set([
+	SyntaxKind.VariableDeclaration,
+	SyntaxKind.FunctionDeclaration,
+	SyntaxKind.ClassDeclaration,
+	SyntaxKind.InterfaceDeclaration,
+	SyntaxKind.TypeAliasDeclaration,
+	SyntaxKind.EnumDeclaration,
+	SyntaxKind.PropertySignature,
+	SyntaxKind.PropertyAssignment,
+	SyntaxKind.PropertyDeclaration
+]);
+const isAnnotatable = (node) => ANNOTATABLE_KINDS.has(node.kind);
+const isConstList = (list) => Option.fromUndefinedOr(list.getFirstToken()).pipe(Option.exists((token) => token.kind === SyntaxKind.ConstKeyword));
+const isModuleStatementList = (list) => isVariableStatement(list.parent) && isSourceFile(list.parent.parent);
+const isModuleConstList = (node) => isVariableDeclarationList(node) && isModuleStatementList(node) && isConstList(node);
+const isModuleConst = (node) => isVariableDeclaration(node) && isIdentifier(node.name) && isModuleConstList(node.parent);
+const objectValuesOf = (checker) => (type) => literalValuesOf(pipe(checker.getPropertiesOfType(type), Array.map((property) => checker.getTypeOfSymbol(property))));
+const ownerValuesOf = (checker) => (declaration) => {
+	const type = checker.getTypeAtLocation(declaration.name);
+	return finiteValuesOf(checker)(type).pipe(Option.orElse(() => objectValuesOf(checker)(type)));
+};
+const annotationProblem = (message) => problemAt({
+	rule: "owner-annotation",
+	message
+});
+const scanned = (owners, problems) => ({
+	owners,
+	problems
+});
+const ownerOf = (project) => (annotated) => {
+	const { node, conceptId } = annotated;
+	if (!isModuleConst(node)) return scanned([], [annotationProblem(`@${OWNER_TAG} registers an owner only on a module-scope const.`)(node)]);
+	if (conceptId === "") return scanned([], [annotationProblem(`@${OWNER_TAG} needs a concept id.`)(node)]);
+	const values = ownerValuesOf(project.checker)(node);
+	return Option.match(Option.all([values, ownerKeyOf(node)]), {
+		onNone: () => scanned([], [annotationProblem(`The owner of ${conceptId} holds no finite value set.`)(node)]),
+		onSome: ([ownedValues, key]) => scanned([{
+			conceptId,
+			key,
+			name: node.name.getText(),
+			file: node.getSourceFile().fileName,
+			line: lineOf(node),
+			column: columnOf(node),
+			packageName: project.packageName,
+			values: ownedValues
+		}], [])
+	});
+};
+const annotatedIn = (sourceFile) => pipe(descendantsOf(sourceFile), Array.filter((node) => isAnnotatable(node)), Array.flatMap((node) => annotationsOf(node)));
+const ownerProblem = (message) => (owner) => ({
+	file: owner.file,
+	line: owner.line,
+	column: owner.column,
+	rule: "owner-annotation",
+	message
+});
+const conflictProblems = (owners) => pipe(owners, Array.flatMap((owner, index) => {
+	const earlier = Array.take(owners, index);
+	const sameConcept = pipe(earlier, Array.filter((other) => other.conceptId === owner.conceptId));
+	const sameSet = pipe(earlier, Array.filter((other) => other.conceptId !== owner.conceptId && sameValues(other.values, owner.values)));
+	return [...pipe(Array.take(sameConcept, FIRST_OWNER_COUNT), Array.map(() => ownerProblem(`The concept ${owner.conceptId} already has an owner.`)(owner))), ...pipe(Array.take(sameSet, FIRST_OWNER_COUNT), Array.map((other) => ownerProblem(`The values ${formatValues(owner.values)} are already owned by ${other.conceptId}.`)(owner)))];
+}));
+const ownersIn = (project) => {
+	const results = pipe(project.sourceFiles, Array.flatMap((sourceFile) => pipe(annotatedIn(sourceFile), Array.map((annotated) => ownerOf(project)(annotated)))));
+	return scanned(pipe(results, Array.flatMap((result) => result.owners)), pipe(results, Array.flatMap((result) => result.problems)));
+};
+const combineOwnerScans = (scans) => {
+	const owners = Array.dedupeWith(pipe(scans, Array.flatMap((scan) => scan.owners)), (left, right) => left.key === right.key);
+	return {
+		owners,
+		problems: [...pipe(scans, Array.flatMap((scan) => scan.problems)), ...conflictProblems(owners)]
+	};
+};
+// src/library.ts
+const NAMESPACE_DEPTH_LIMIT = 8;
+const EMPTY_INDEX = {
+	vocabularies: [],
+	shapes: []
+};
+const isObjectType = (checker) => (type) => !type.isUnionType() && !type.isLiteralType() && checker.getApparentType(type).id === type.id && Array.isReadonlyArrayNonEmpty(checker.getPropertiesOfType(type));
+const describeLibraryType = (type) => `${type.typeName} from ${type.specifier}`;
+const locationOf = (declaration) => ({
+	file: declaration.getSourceFile().fileName,
+	pos: declaration.pos,
+	kind: declaration.kind
+});
+const declarationKey = (location) => `${location.file}#${String(location.pos)}#${String(location.kind)}`;
+const shapeOf = (checker) => (source, declaration, type) => Array.filter([{
+	...source,
+	declaration: locationOf(declaration),
+	propertyNames: propertyNamesOf(checker)(type)
+}], () => isObjectType(checker)(type));
+const declaredTypeIndex = (walk, exported) => {
+	const declaration = Array.findFirst(declarationsOf(exported.symbol), isTypeDeclaration);
+	if (Option.isNone(declaration) || isGenericDeclaration(declaration.value)) return EMPTY_INDEX;
+	const located = {
+		specifier: walk.entry.specifier,
+		typeName: exported.typeName
+	};
+	const type = walk.checker.getDeclaredTypeOfSymbol(exported.symbol);
+	return {
+		vocabularies: vocabularyOf(walk.checker)(type).pipe(Option.map((vocabulary) => ({
+			...located,
+			vocabulary
+		})), Option.toArray),
+		shapes: shapeOf(walk.checker)({
+			...located,
+			form: "declared"
+		}, declaration.value, type)
+	};
+};
+const schemaTypeIndex = (walk, located) => (declaration, schemaType) => ({
+	vocabularies: vocabularyOf(walk.checker)(schemaType).pipe(Option.map((vocabulary) => ({
+		...located,
+		vocabulary
+	})), Option.toArray),
+	shapes: shapeOf(walk.checker)({
+		...located,
+		form: "schema"
+	}, declaration, schemaType)
+});
+const schemaValueIndex = (walk, exported) => {
+	const declaration = Array.findFirst(declarationsOf(exported.symbol), isVariableDeclaration);
+	if (Option.isNone(declaration)) return EMPTY_INDEX;
+	const valueType = walk.checker.getTypeOfSymbolAtLocation(exported.symbol, declaration.value);
+	const located = {
+		specifier: walk.entry.specifier,
+		typeName: `(typeof ${exported.typeName})["Type"]`
+	};
+	return Option.match(schemaTypeOf(walk.checker)(valueType), {
+		onNone: () => EMPTY_INDEX,
+		onSome: (schemaType) => schemaTypeIndex(walk, located)(declaration.value, schemaType)
+	});
+};
+const mergeIndexes = (indexes) => ({
+	vocabularies: pipe(indexes, Array.flatMap((index) => index.vocabularies)),
+	shapes: pipe(indexes, Array.flatMap((index) => index.shapes))
+});
+const isNamespace = (symbol) => pipe(declarationsOf(symbol), Array.some((declaration) => isModuleDeclaration(declaration)));
+const indexUnder = (walk, visit) => {
+	const symbol = resolvedSymbol(walk.checker)(visit.exported);
+	const named = {
+		symbol,
+		typeName: `${visit.qualifier}${visit.exported.name}`
+	};
+	const own = mergeIndexes([declaredTypeIndex(walk, named), schemaValueIndex(walk, named)]);
+	if (!isNamespace(symbol) || visit.ancestors.length >= NAMESPACE_DEPTH_LIMIT || visit.ancestors.includes(symbol)) return own;
+	const nested = pipe(walk.checker.getExportsOfModule(symbol), Array.map((member) => indexUnder(walk, {
+		exported: member,
+		qualifier: `${named.typeName}.`,
+		ancestors: [...visit.ancestors, symbol]
+	})));
+	return mergeIndexes([own, ...nested]);
+};
+const exportAssignmentOf = (moduleSymbol) => Option.fromUndefinedOr(moduleSymbol.getExports().get(InternalSymbolName.ExportEquals));
+const indexOfEntry = (checker) => (entry) => {
+	const moduleSymbol = Option.fromUndefinedOr(checker.getSymbolOfSourceFile(entry.declarationsPath));
+	if (Option.isNone(moduleSymbol)) return EMPTY_INDEX;
+	const walk = {
+		checker,
+		entry
+	};
+	const roots = Option.match(exportAssignmentOf(moduleSymbol.value), {
+		onNone: () => checker.getExportsOfModule(moduleSymbol.value),
+		onSome: (assigned) => [resolvedSymbol(checker)(assigned)]
+	});
+	return mergeIndexes(pipe(roots, Array.map((exported) => indexUnder(walk, {
+		exported,
+		qualifier: "",
+		ancestors: []
+	}))));
+};
+const libraryCache = () => {
+	const indexes = /* @__PURE__ */ new Map();
+	return { indexOf: (entry, compute) => Option.match(Option.fromUndefinedOr(indexes.get(entry.declarationsPath)), {
+		onSome: (index) => ({
+			index,
+			cached: true
+		}),
+		onNone: () => {
+			const index = compute();
+			indexes.set(entry.declarationsPath, index);
+			return {
+				index,
+				cached: false
+			};
+		}
+	}) };
+};
+const indexEntry = (cache) => (checker) => (entry) => Effect.sync(() => cache.indexOf(entry, () => indexOfEntry(checker)(entry))).pipe(Effect.tap(({ index, cached }) => Effect.annotateCurrentSpan({
+	"msch.library.cached": cached,
+	"msch.library.vocabularies": index.vocabularies.length,
+	"msch.library.shapes": index.shapes.length
+})), Effect.map(({ index }) => index), Effect.withSpan("indexLibraryEntry", { attributes: { "msch.library.specifier": entry.specifier } }));
+const libraryIndex = (cache) => (checker) => (entries) => pipe(entries, Effect.forEach(indexEntry(cache)(checker)), Effect.map(mergeIndexes), Effect.withSpan("libraryIndex"));
+// src/shapes.ts
+const MINIMUM_SHAPE_PROPERTIES = 3;
+const EXACT = 0;
+const augmentsAModule = (node) => {
+	const block = node.parent;
+	return isModuleBlock(block) && isModuleDeclaration(block.parent) && isStringLiteral(block.parent.name);
+};
+const isPlainInterface = (node) => isInterfaceDeclaration(node) && !isGenericDeclaration(node) && !augmentsAModule(node);
+const isPlainTypeLiteral = (node) => isTypeAliasDeclaration(node) && !isGenericDeclaration(node) && isTypeLiteralNode(node.type);
+const isDeclaredShape = (node) => isPlainInterface(node) || isPlainTypeLiteral(node);
+const declaredShapeOf = (checker) => (node) => Option.liftPredicate(node, isDeclaredShape).pipe(Option.map((declaration) => checker.getTypeAtLocation(declaration.name)));
+const schemaShapeOf = (checker) => (node) => {
+	if (!isCallExpression(node)) return Option.none();
+	const { arguments: callArguments } = node;
+	if (!pipe(callArguments, Array.some((argument) => isObjectLiteralExpression(argument)))) return Option.none();
+	return schemaTypeOf(checker)(checker.getTypeAtLocation(node)).pipe(Option.filter((type) => isObjectType(checker)(type)));
+};
+const shapeSitesIn = (checker) => (sourceFile) => Array.getSomes(pipe(descendantsOf(sourceFile), Array.map((node) => declaredShapeOf(checker)(node).pipe(Option.orElse(() => schemaShapeOf(checker)(node)), Option.map((type) => ({
+	node,
+	type
+}))))));
+const openTypeIdsOf = (checker) => ({
+	any: checker.getAnyType().id,
+	unknown: checker.getUnknownType().id
+});
+const isIndexedDeclaration = (node) => isTypeDeclaration(node) || isVariableDeclaration(node);
+const declarationAt = (program) => (location) => Option.fromUndefinedOr(program.getSourceFile(location.file)).pipe(Option.flatMap((sourceFile) => Array.findFirst(descendantsOf(sourceFile), (node) => node.pos === location.pos && node.kind === location.kind && isIndexedDeclaration(node))));
+const symbolOfDeclaration = (checker) => (declaration) => Option.fromUndefinedOr(checker.getSymbolAtLocation(declaration.name));
+const shapeTypeOf = (context) => (shape) => {
+	const { checker } = context;
+	return declarationAt(context.program)(shape.declaration).pipe(Option.flatMap((declaration) => symbolOfDeclaration(checker)(declaration).pipe(Option.flatMap((symbol) => {
+		if (shape.form === "declared") return Option.some(checker.getDeclaredTypeOfSymbol(symbol));
+		return schemaTypeOf(checker)(checker.getTypeOfSymbolAtLocation(symbol, declaration));
+	}))));
+};
+const hasEveryName = (locals) => (shape) => {
+	const names = new Set(shape.propertyNames);
+	return pipe(locals, Array.every((local) => names.has(local.name)));
+};
+const sameProperty = (checker, open) => (localType, library) => {
+	const libraryType = checker.getTypeOfSymbol(library);
+	return libraryType.id !== open.any && libraryType.id !== open.unknown && checker.isTypeAssignableTo(localType, libraryType) && checker.isTypeAssignableTo(libraryType, localType);
+};
+const matchOf = (context, open) => (locals, shape) => {
+	const { checker } = context;
+	if (!shapeTypeOf(context)(shape).pipe(Option.exists((shapeType) => pipe(locals, Array.every((local) => Option.fromUndefinedOr(checker.getPropertyOfType(shapeType, local.name)).pipe(Option.exists((library) => sameProperty(checker, open)(local.type, library)))))))) return Option.none();
+	return Option.some({
+		shape,
+		extra: shape.propertyNames.length - locals.length
+	});
+};
+const localPropertiesOf = (checker) => (symbols) => pipe(Array.zip(symbols, checker.getTypeOfSymbol(symbols)), Array.map(([symbol, type]) => ({
+	name: symbol.name,
+	type
+})));
+const derivedDeclarationsOf = (checker) => (node) => new Set(pipe(referencedSymbols(checker)(node), Array.flatMap((symbol) => declarationsOf(symbol)), Array.map((declaration) => declarationKey(locationOf(declaration)))));
+const matchOrder = Order.mapInput(Order.Number, (match) => match.extra);
+const shapeProblem = (site, matches) => {
+	const shown = pipe(Array.take(matches, 3), Array.map((match) => describeLibraryType(match.shape)), Array.join(", "));
+	const advice = Option.match(Array.findFirst(matches, (match) => match.extra === EXACT), {
+		onNone: () => "Derive it from the library type, for example with Pick, instead of copying its properties.",
+		onSome: () => "Use the library type instead of copying it."
+	});
+	return problemAt({
+		rule: "library-shape",
+		message: `This shape copies ${shown}. ${advice}`
+	})(site.node);
+};
+const shapeProblemOf = (context, open) => (site) => {
+	const symbols = context.checker.getPropertiesOfType(site.type);
+	if (symbols.length < MINIMUM_SHAPE_PROPERTIES) return Option.none();
+	const locals = localPropertiesOf(context.checker)(symbols);
+	const derived = derivedDeclarationsOf(context.checker)(site.node);
+	const candidates = pipe(context.shapes, Array.filter(hasEveryName(locals)), Array.filter((shape) => !derived.has(declarationKey(shape.declaration))), Array.map((shape) => matchOf(context, open)(locals, shape)), Array.getSomes);
+	const matches = Array.sort(candidates, matchOrder);
+	return Option.liftPredicate(matches, Array.isReadonlyArrayNonEmpty).pipe(Option.map((found) => shapeProblem(site, found)));
+};
+const shapeProblemsIn = (context) => (sourceFile) => {
+	const sites = shapeSitesIn(context.checker)(sourceFile);
+	if (!Array.isReadonlyArrayNonEmpty(sites)) return [];
+	const open = openTypeIdsOf(context.checker);
+	return Array.getSomes(pipe(sites, Array.map((site) => shapeProblemOf(context, open)(site))));
+};
+// src/sites.ts
+const namedValuesOf = (checker) => (symbol) => {
+	if (pipe(declarationsOf(symbol), Array.some((declaration) => isTypeDeclaration(declaration)))) return finiteValuesOf(checker)(checker.getDeclaredTypeOfSymbol(symbol));
+	return finiteValuesOf(checker)(checker.getTypeOfSymbol(symbol));
+};
+const hasFiniteContext = (checker) => (node) => Option.fromUndefinedOr(checker.getContextualType(node)).pipe(Option.flatMap(finiteValuesOf(checker)), Option.isSome);
+const isNamedValue = (element) => isIdentifier(element) || isPropertyAccessExpression(element) || isElementAccessExpression(element);
+const namesEveryElement = (array) => pipe(array.elements, Array.every((element) => isNamedValue(element)));
+const expressionValuesOf = (checker) => (node) => {
+	if (hasFiniteContext(checker)(node)) return Option.none();
+	const type = checker.getTypeAtLocation(node);
+	if (isArrayLiteralExpression(node)) return Option.liftPredicate(node, (array) => !namesEveryElement(array)).pipe(Option.flatMap(() => finiteValuesOf(checker)(type)));
+	return schemaTypeOf(checker)(type).pipe(Option.flatMap(literalUnionOf));
+};
+const selectsKeys = (checker) => (node, values) => {
+	const { parent } = node;
+	if (!isTypeReferenceNode(parent)) return false;
+	const typeArguments = parent.typeArguments ?? [];
+	return pipe(typeArguments, Array.filter((argument) => argument !== node), Array.some((argument) => isSubsetOf(values, propertyNamesOf(checker)(checker.getTypeFromTypeNode(argument)))));
+};
+const unionValuesOf = (checker) => (node) => literalUnionOf(checker.getTypeFromTypeNode(node)).pipe(Option.filter((values) => !selectsKeys(checker)(node, values)));
+const isExpressionSite = (node) => isArrayLiteralExpression(node) || isCallExpression(node);
+const expressionSiteValuesOf = (checker) => (node) => Option.liftPredicate(node, isExpressionSite).pipe(Option.flatMap(expressionValuesOf(checker)));
+const siteValuesOf = (checker) => (node) => {
+	if (isUnionTypeNode(node)) return unionValuesOf(checker)(node);
+	if (isEnumDeclaration(node)) return literalUnionOf(checker.getTypeAtLocation(node.name));
+	return expressionSiteValuesOf(checker)(node);
+};
+const derivationScopeOf = (node) => {
+	if (isTypeReferenceNode(node.parent)) return node.parent;
+	return node;
+};
+const sourcesOf = (checker) => (node) => pipe(referencedSymbols(checker)(derivationScopeOf(node)), Array.filter((symbol) => Option.isSome(namedValuesOf(checker)(symbol))));
+const sitesUnder = (checker) => (node) => {
+	const nested = pipe(childrenOf(node), Array.flatMap((child) => sitesUnder(checker)(child)));
+	if (Array.isReadonlyArrayNonEmpty(nested)) return nested;
+	return siteValuesOf(checker)(node).pipe(Option.map((values) => ({
+		node,
+		values,
+		sources: sourcesOf(checker)(node)
+	})), Option.toArray);
+};
+// src/value-checks.ts
+const OWNER_SEARCH_DEPTH = 4;
+const NOTHING_HIDDEN = 0;
+const directOwners = (context) => (symbol) => {
+	const keys = Array.getSomes(pipe(declarationsOf(symbol), Array.map((declaration) => ownerKeyOf(declaration))));
+	return pipe(context.owners, Array.filter((owner) => keys.includes(owner.key)));
+};
+const isFollowable = (declaration) => !declaration.getSourceFile().isDeclarationFile && (isTypeAliasDeclaration(declaration) || isVariableDeclaration(declaration));
+const ownersBehind = (context) => (symbol, ancestors) => {
+	const direct = directOwners(context)(symbol);
+	if (Array.isReadonlyArrayNonEmpty(direct) || ancestors.length >= OWNER_SEARCH_DEPTH) return direct;
+	const visited = [...ancestors, symbol];
+	return uniqueByReference(pipe(declarationsOf(symbol), Array.filter((declaration) => isFollowable(declaration)), Array.flatMap((declaration) => referencedSymbols(context.checker)(declaration)), Array.filter((referenced) => !visited.includes(referenced)), Array.flatMap((referenced) => ownersBehind(context)(referenced, visited))));
+};
+const describeOwners = (owners) => pipe(owners, Array.map((owner) => `${owner.conceptId} (${owner.name})`), Array.join(", "));
+const verdict = (problems, unowned) => ({
+	problems,
+	unowned
+});
+const derivedVerdict = (context) => (site) => {
+	const owners = uniqueByReference(pipe(site.sources, Array.flatMap((source) => ownersBehind(context)(source, []))));
+	const held = pipe(owners, Array.flatMap((owner) => owner.values));
+	const added = pipe(site.values, Array.filter((value) => !isSubsetOf([value], held)));
+	if (!Array.isReadonlyArrayNonEmpty(owners) || !Array.isReadonlyArrayNonEmpty(added)) return verdict([], []);
+	const message = `This set adds ${formatValues(added)} to ${describeOwners(owners)}. Add the values to the owner, or register the wider set as its own concept.`;
+	return verdict([problemAt({
+		rule: "owner-extension",
+		message
+	})(site.node)], []);
+};
+const libraryCandidates = (context) => (site) => {
+	const flowing = Array.dedupe(pipe(context.flows, Array.filter((flow) => flow.site.node === site.node), Array.map((flow) => flow.target)));
+	if (Array.isReadonlyArrayNonEmpty(flowing)) return flowing;
+	if (!pipe(site.values, Array.some((value) => typeof value === "string"))) return [];
+	const imported = importedModulesOf(site.node.getSourceFile());
+	return Array.dedupe(pipe(context.vocabularies, Array.filter((library) => imported.includes(library.specifier)), Array.filter((library) => isSubsetOf(site.values, library.vocabulary.values)), Array.map((library) => describeLibraryType(library))));
+};
+const listCandidates = (candidates) => {
+	const shown = pipe(Array.take(candidates, 3), Array.join(", "));
+	const hidden = candidates.length - 3;
+	if (hidden > NOTHING_HIDDEN) return `${shown} and ${String(hidden)} more`;
+	return shown;
+};
+const originalVerdict = (context) => (site) => {
+	const owners = pipe(context.owners, Array.filter((owner) => isSubsetOf(site.values, owner.values)));
+	if (Array.isReadonlyArrayNonEmpty(owners)) {
+		const message = `The values ${formatValues(site.values)} are owned by ${describeOwners(owners)}. Derive this set from the owner instead of restating it.`;
+		return verdict([problemAt({
+			rule: "owner-value-set",
+			message
+		})(site.node)], []);
+	}
+	const candidates = libraryCandidates(context)(site);
+	if (Array.isReadonlyArrayNonEmpty(candidates)) {
+		const message = `The values ${formatValues(site.values)} restate a dependency type: ${listCandidates(candidates)}. Derive this set from the library type.`;
+		return verdict([problemAt({
+			rule: "library-value-set",
+			message
+		})(site.node)], []);
+	}
+	return verdict([], [site]);
+};
+const siteVerdict = (context) => (site) => {
+	if (Array.isReadonlyArrayNonEmpty(site.sources)) return derivedVerdict(context)(site);
+	return originalVerdict(context)(site);
+};
+const VALUE_PARENT_KINDS = /* @__PURE__ */ new Set([
+	SyntaxKind.ReturnStatement,
+	SyntaxKind.ArrayLiteralExpression,
+	SyntaxKind.ConditionalExpression,
+	SyntaxKind.ParenthesizedExpression,
+	SyntaxKind.ArrowFunction,
+	SyntaxKind.JsxExpression
+]);
+const isCallArgument = (node, parent) => (isCallExpression(parent) || isNewExpression(parent)) && parent.expression !== node;
+const isInitializer = (node, parent) => (isPropertyAssignment(parent) || isVariableDeclaration(parent)) && parent.initializer === node;
+const isRightOperand = (node, parent) => isBinaryExpression(parent) && parent.right === node;
+const VALUE_SLOTS = [
+	isCallArgument,
+	isInitializer,
+	isRightOperand
+];
+const isValuePosition = (node) => {
+	const { parent } = node;
+	return VALUE_PARENT_KINDS.has(parent.kind) || pipe(VALUE_SLOTS, Array.some((isSlot) => isSlot(node, parent)));
+};
+const ownedLiteralProblem = (context) => (literal) => Option.fromUndefinedOr(context.checker.getContextualType(literal)).pipe(Option.filter((contextual) => vocabularyOf(context.checker)(contextual).pipe(Option.exists((vocabulary) => !vocabulary.admitsUnnamedValues))), Option.map(() => pipe(contextSymbolsOf(context.checker)(literal), Array.flatMap((symbol) => ownersBehind(context)(symbol, [])), uniqueByReference, Array.filter((owner) => isSubsetOf([literal.text], pipe(owner.values, Array.map(String)))))), Option.filter((owners) => Array.isReadonlyArrayNonEmpty(owners)), Option.map((owners) => problemAt({
+	rule: "owned-literal",
+	message: `${literal.getText()} is a value of ${describeOwners(owners)}. Write it through the owner's binding instead of as a literal.`
+})(literal)));
+const ownedLiteralProblems = (context) => (sourceFile, excluded) => Array.getSomes(pipe(descendantsOf(sourceFile), Array.filter((node) => isStringLiteral(node) || isNumericLiteral(node)), Array.filter((node) => isValuePosition(node)), Array.filter((node) => !pipe(excluded, Array.some((outer) => contains(outer)(node)))), Array.map((node) => ownedLiteralProblem(context)(node))));
+// src/analysis.ts
+const isVisibleTo = (project) => (owner) => pipe(project.sourceFiles, Array.some((sourceFile) => sourceFile.fileName === owner.file)) || Option.exists(owner.packageName, (name) => Option.contains(project.packageName, name) || project.workspaceDependencies.includes(name));
+const ownerDeclarationsIn = (project, owners) => {
+	const keys = new Set(pipe(owners, Array.map((owner) => owner.key)));
+	return pipe(project.sourceFiles, Array.flatMap((sourceFile) => pipe(descendantsOf(sourceFile), Array.filter((node) => isVariableDeclaration(node)), Array.filter((declaration) => Option.exists(ownerKeyOf(declaration), (key) => keys.has(key))))));
+};
+const isInside = (outers) => (node) => pipe(outers, Array.some((outer) => contains(outer)(node)));
+const sitesOutside = (checker) => (project, outers) => pipe(project.sourceFiles, Array.flatMap((sourceFile) => sitesUnder(checker)(sourceFile)), Array.filter((site) => !isInside(outers)(site.node)));
+const nodesOf = (sites) => pipe(sites, Array.map((site) => site.node));
+const analyzeProject = (owners) => (project) => {
+	const { checker } = project;
+	const ownerDeclarations = ownerDeclarationsIn(project, owners);
+	const sites = sitesOutside(checker)(project, ownerDeclarations);
+	const flowContext = {
+		checker,
+		program: project.program,
+		sites
+	};
+	const context = {
+		checker,
+		owners: pipe(owners, Array.filter((owner) => isVisibleTo(project)(owner))),
+		vocabularies: project.library.vocabularies,
+		flows: pipe(project.sourceFiles, Array.flatMap((sourceFile) => flowsIn(flowContext)(sourceFile)))
+	};
+	const verdicts = pipe(sites, Array.map((site) => siteVerdict(context)(site)));
+	const excluded = [...ownerDeclarations, ...nodesOf(sites)];
+	const shapeContext = {
+		checker,
+		program: project.program,
+		shapes: project.library.shapes
+	};
+	return {
+		problems: [...pipe(verdicts, Array.flatMap((found) => found.problems)), ...pipe(project.sourceFiles, Array.flatMap((sourceFile) => [...ownedLiteralProblems(context)(sourceFile, excluded), ...shapeProblemsIn(shapeContext)(sourceFile)]))],
+		unowned: pipe(verdicts, Array.flatMap((found) => found.unowned))
+	};
+};
+// src/duplicates.ts
+const DUPLICATE_THRESHOLD = 1;
+const unownedSiteOf = (scope) => (site) => ({
+	scope,
+	file: site.node.getSourceFile().fileName,
+	start: site.node.getStart(),
+	line: lineOf(site.node),
+	column: columnOf(site.node),
+	values: site.values
+});
+const canDerive = (left, right) => left.scope.name === right.scope.name || left.scope.dependencies.includes(right.scope.name) || right.scope.dependencies.includes(left.scope.name);
+const siteKey = (site) => `${site.file}#${String(site.start)}`;
+const valueSetKey = (site) => {
+	const keys = pipe(site.values, Array.map((value) => valueKey(value)));
+	return pipe(Array.sort(keys, Order.String), Array.join("\0"));
+};
+const duplicateProblems = (relative) => (sites) => {
+	const unique = Array.dedupeWith(sites, (left, right) => siteKey(left) === siteKey(right));
+	const groups = Record.values(Array.groupBy(unique, (site) => valueSetKey(site)));
+	return pipe(groups, Array.filter((group) => group.length > DUPLICATE_THRESHOLD), Array.flatMap((group) => pipe(group, Array.flatMap((site) => {
+		const related = pipe(group, Array.filter((other) => other !== site && canDerive(site, other)));
+		if (!Array.isReadonlyArrayNonEmpty(related)) return [];
+		const others = pipe(related, Array.map((other) => `${relative(other.file)}:${String(other.line)}`), Array.join(", "));
+		return [{
+			file: site.file,
+			line: site.line,
+			column: site.column,
+			rule: "duplicate-value-set",
+			message: `The values ${formatValues(site.values)} are also declared at ${others}. Register one owner with /** @${OWNER_TAG} <concept> */ and derive the others from it.`
+		}];
+	}))));
+};
+// src/telemetry.ts
+const RSS_LINE = /^VmRSS:\s+(?<kib>\d+) kB$/mu;
+const BYTES_PER_KIB = 1024;
+const UNKNOWN_RSS = 0;
+const kibibytesIn = (status) => Option.fromNullishOr(RSS_LINE.exec(status)).pipe(Option.flatMap((match) => Option.fromUndefinedOr(match.groups)), Option.flatMap((groups) => Option.fromUndefinedOr(groups["kib"])));
+const residentBytesOf = (pid) => Effect.gen(function* residentBytes() {
+	const status = yield* (yield* RepositoryFiles).readFile(`/proc/${pid}/status`);
+	return pipe(status, Option.flatMap(kibibytesIn), Option.flatMap(Number$1.parse), Option.map((kib) => kib * BYTES_PER_KIB), Option.getOrElse(() => UNKNOWN_RSS));
+});
+const childPids = Effect.gen(function* childPids() {
+	const files = yield* RepositoryFiles;
+	const pid = String(process.pid);
+	const children = yield* files.readFile(`/proc/${pid}/task/${pid}/children`);
+	return pipe(children, Option.map((text) => pipe(String$1.trim(text), String$1.split(" "), Array.filter(String$1.isNonEmpty))), Option.getOrElse(() => []));
+});
+const annotateMemory = Effect.gen(function* annotateMemory() {
+	const own = yield* residentBytesOf(String(process.pid));
+	const pids = yield* childPids;
+	const children = yield* pipe(pids, Effect.forEach((pid) => residentBytesOf(pid)));
+	const { heapUsed } = process.memoryUsage();
+	yield* Effect.annotateCurrentSpan({
+		"process.memory.rss": own,
+		"process.memory.heap_used": heapUsed,
+		"msch.compiler.memory.rss": Number$1.sumAll(children)
+	});
+});
+const annotateResources = (api) => Effect.gen(function* annotateCompiler() {
+	yield* annotateMemory;
+	const { totals } = api.getTimingInfo();
+	yield* Effect.annotateCurrentSpan({
+		"msch.compiler.requests": totals.requestCount,
+		"msch.compiler.round_trip_ms": totals.roundTripMs,
+		"msch.compiler.server_ms": totals.serverTimeMs
+	});
+});
+// src/project.ts
+const CONFIG_FILE = "tsconfig.json";
+const HIDDEN_PREFIX = ".";
+const SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
+	NODE_MODULES,
+	"dist",
+	"coverage"
+]);
+const listConfigFiles = (directory) => Effect.gen(function* configFilesUnder() {
+	const files = yield* RepositoryFiles;
+	const names = yield* files.readDirectory(directory);
+	const visible = pipe(names, Array.filter((name) => !String$1.startsWith(HIDDEN_PREFIX)(name) && !SKIPPED_DIRECTORIES.has(name)), Array.map((name) => files.join(directory, name)));
+	const nested = yield* Function.pipe(visible, Effect.forEach((entryPath) => files.isDirectory(entryPath).pipe(Effect.flatMap(Option.match({
+		onNone: () => Effect.succeed([]),
+		onSome: (directoryEntry) => {
+			if (directoryEntry) return listConfigFiles(entryPath);
+			return Effect.succeed(Array.filter([entryPath], () => files.basename(entryPath) === CONFIG_FILE));
+		}
+	})))));
+	return Array.sort(nested.flat(), Order.String);
+});
+const parseConfig = (api) => (configPath) => Option.some(api.parseConfigFile(configPath)).pipe(Option.filter((parsed) => Array.isReadonlyArrayNonEmpty(parsed.fileNames)));
+const nearestPackageDirectory = (directory, root) => Effect.gen(function* nearestPackage() {
+	const files = yield* RepositoryFiles;
+	const hasManifest = yield* files.exists(files.join(directory, MANIFEST_FILE));
+	const parent = files.dirname(directory);
+	if (hasManifest || directory === root || parent === directory) return directory;
+	return yield* nearestPackageDirectory(parent, root);
+});
+const packageInfoOf = Effect.fn("packageInfoOf")(function* packageInfoOf(configPath, root) {
+	const files = yield* RepositoryFiles;
+	const directory = yield* nearestPackageDirectory(files.dirname(configPath), root);
+	const manifest = yield* readManifest(directory);
+	return {
+		directory,
+		name: manifest.pipe(Option.flatMap((found) => Option.fromUndefinedOr(found.name))),
+		workspaceDependencies: manifest.pipe(Option.map(workspaceDependencies), Option.getOrElse(() => []))
+	};
+});
+const NO_CHECK_PRAGMA = /^\/\/\s*@ts-nocheck/u;
+const FILE_START = 0;
+const skipsTypeChecking = (sourceFile) => pipe(getLeadingCommentRanges(sourceFile.text, FILE_START) ?? [], Array.some((range) => NO_CHECK_PRAGMA.test(String$1.slice(range.pos, range.end)(sourceFile.text))));
+const buildProject = Effect.fn("buildProject")(function* buildProject({ compiler: { api, libraries }, generated }, parsed, info) {
+	const entries = yield* dependencyEntries(info.directory);
+	const program = yield* Effect.sync(() => api.createProgram([...parsed.fileNames, ...pipe(entries, Array.map((entry) => entry.declarationsPath))], {
+		...parsed.options,
+		noEmit: true
+	})).pipe(Effect.withSpan("createProgram"));
+	const { checker } = program.getProject();
+	const library = yield* libraryIndex(libraries)(checker)(entries);
+	const projectFiles = new Set(pipe(parsed.fileNames, Array.filter((fileName) => !generated.includes(fileName))));
+	return {
+		packageName: info.name,
+		workspaceDependencies: info.workspaceDependencies,
+		program,
+		checker,
+		sourceFiles: pipe(program.getSourceFileNames(), Array.filter((fileName) => projectFiles.has(fileName)), Array.flatMap((fileName) => Option.toArray(Option.fromUndefinedOr(program.getSourceFile(fileName)))), Array.filter((sourceFile) => !sourceFile.isDeclarationFile && !skipsTypeChecking(sourceFile))),
+		library
+	};
+});
+const typeScriptCompiler = Effect.acquireRelease(Effect.sync(() => ({
+	api: new API({ collectTiming: true }),
+	libraries: libraryCache()
+})), ({ api }) => Effect.sync(() => {
+	api.close();
+}));
+const loadProject = Effect.fn("loadProject")(function* loadProject(workspace, configPath) {
+	const { compiler, root } = workspace;
+	const parsed = parseConfig(compiler.api)(configPath);
+	if (Option.isNone(parsed)) return Option.none();
+	const info = yield* packageInfoOf(configPath, root);
+	const project = yield* buildProject(workspace, parsed.value, info);
+	yield* Effect.annotateCurrentSpan({
+		"msch.project.config": configPath,
+		"msch.project.program_files": project.program.getSourceFileNames().length,
+		"msch.project.source_files": project.sourceFiles.length
+	});
+	yield* annotateResources(compiler.api);
+	return Option.some(project);
+});
+const releaseProject = (project) => Effect.sync(() => {
+	project.program.dispose();
+});
+const withProject = (workspace) => (configPath) => (work) => Effect.acquireUseRelease(loadProject(workspace, configPath), (loaded) => Option.match(loaded, {
+	onNone: () => Effect.succeedNone,
+	onSome: (project) => work(project).pipe(Effect.asSome)
+}), (loaded) => Option.match(loaded, {
+	onNone: () => Effect.void,
+	onSome: releaseProject
+}));
+const mentions = (needle) => ({ api }) => (configPath) => Effect.gen(function* mentionsNeedle() {
+	const files = yield* RepositoryFiles;
+	const fileNames = Option.match(parseConfig(api)(configPath), {
+		onNone: () => [],
+		onSome: (parsed) => parsed.fileNames
+	});
+	const texts = yield* pipe(fileNames, Effect.forEach((fileName) => files.readFile(fileName)));
+	const includesNeedle = String$1.includes(needle);
+	return pipe(texts, Array.some((text) => Option.exists(text, includesNeedle)));
+});
+// src/check.ts
+const scanOwners = Effect.fn("scanOwners")(function* scanOwners(workspace, configPaths) {
+	const ownerConfigs = yield* pipe(configPaths, Effect.filter(mentions(`@${OWNER_TAG}`)(workspace.compiler)));
+	const scans = yield* pipe(ownerConfigs, Effect.forEach((configPath) => withProject(workspace)(configPath)((project) => Effect.sync(() => ownersIn(project)))));
+	return combineOwnerScans(Array.getSomes(scans));
+});
+const scopeOf = (project, configPath) => ({
+	name: Option.getOrElse(project.packageName, () => configPath),
+	dependencies: project.workspaceDependencies
+});
+const analyzeProjects = (workspace, owners) => (configPaths) => pipe(configPaths, Effect.forEach((configPath) => withProject(workspace)(configPath)((project) => Effect.sync(() => {
+	const analysis = analyzeProject(owners)(project);
+	const scope = scopeOf(project, configPath);
+	return {
+		problems: analysis.problems,
+		unowned: pipe(analysis.unowned, Array.map(unownedSiteOf(scope)))
+	};
+}).pipe(Effect.withSpan("analyzeProject")))), Effect.map(Array.getSomes));
+const checkRepository = Effect.fn("checkRepository")(function* checkRepository(root) {
+	const files = yield* RepositoryFiles;
+	const workspace = {
+		compiler: yield* typeScriptCompiler,
+		root,
+		generated: yield* files.generatedFiles(root)
+	};
+	const configPaths = yield* listConfigFiles(root);
+	const ownerScan = yield* scanOwners(workspace, configPaths);
+	const analyses = yield* analyzeProjects(workspace, ownerScan.owners)(configPaths);
+	const relative = (file) => files.relative(root, file);
+	const unowned = pipe(analyses, Array.flatMap((analysis) => analysis.unowned));
+	return sortProblems([
+		...ownerScan.problems,
+		...pipe(analyses, Array.flatMap((analysis) => analysis.problems)),
+		...duplicateProblems(relative)(unowned)
+	]);
+}, Effect.scoped);
+// src/text-position.ts
+const START$1 = 0;
+const FIRST_COLUMN$1 = 1;
+const positionOf = (source) => (index) => {
+	const before = pipe(source, String$1.slice(START$1, index), String$1.split("\n"));
+	return {
+		line: before.length,
+		column: pipe(Array.last(before), Option.match({
+			onNone: () => FIRST_COLUMN$1,
+			onSome: (last) => last.length + FIRST_COLUMN$1
+		}))
+	};
+};
+// src/hidden-unicode.ts
+const HIDDEN = /[\u00AD\u180E\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u2069\uFEFF]|[\u{E0000}-\u{E007F}]/gu;
+const NUL = "\0";
+const START = 0;
+const HEX = 16;
+const CODE_POINT_WIDTH = 4;
+const READ_CONCURRENCY$1 = 64;
+const RULE = "hidden-unicode";
+const hexOf = (character) => pipe(String$1.codePointAt(START)(character), Option.getOrElse(() => START), (code) => code.toString(HEX), String$1.toUpperCase, String$1.padStart(CODE_POINT_WIDTH, "0"));
+const problemOf = (file, source) => (found) => {
+	const hex = hexOf(found[START]);
+	return {
+		file,
+		...positionOf(source)(found.index ?? START),
+		rule: RULE,
+		message: `U+${hex} is invisible in editors and reviews and can change what the text means. Remove it, or write it as the escape \\u${hex}.`
+	};
+};
+const problemsIn = (file, source) => {
+	if (String$1.includes(NUL)(source)) return [];
+	return pipe(Array.fromIterable(String$1.matchAll(HIDDEN)(source)), Array.map(problemOf(file, source)));
+};
+/** @internal */
+const checkHiddenUnicode = Effect.fn("checkHiddenUnicode")(function* checkHiddenUnicode(root) {
+	const files = yield* RepositoryFiles;
+	const names = yield* files.listedFiles(root);
+	const found = yield* Effect.forEach(names, (name) => {
+		const file = files.join(root, name);
+		return files.readFile(file).pipe(Effect.map(Option.match({
+			onNone: () => [],
+			onSome: (source) => problemsIn(file, source)
+		})));
+	}, { concurrency: READ_CONCURRENCY$1 });
+	return Array.flatten(found);
+});
+// src/output.ts
+const taggedError$1 = Schema.TaggedError;
+var ProblemsFound = class extends taggedError$1()("ProblemsFound", { count: Schema.Finite }) {};
+/** @internal */
+const writeStdout = Effect.fn("writeStdout")(function* writeStdout(text) {
+	const stdio = yield* Stdio.Stdio;
+	yield* Stream.make(text).pipe(Stream.run(stdio.stdout()), Effect.orDie);
+});
+// src/override-findings.ts
+const describeVersions = (versions) => Option.getOrElse(Option.liftPredicate(Array.join(versions, ","), (joined) => joined !== ""), () => "-");
+const describeChanges = (report) => {
+	const versions = pipe(report.changes, Array.map((change) => `${change.name} ${describeVersions(change.before)} -> ${describeVersions(change.after)}`));
+	const contexts = Array.filter(["the peer contexts"], () => report.peerContextsChanged);
+	return Array.join([...versions, ...contexts], "; ");
+};
+const overrideProblem = (located) => (report) => {
+	const at = {
+		file: located.file,
+		line: located.line,
+		column: located.column
+	};
+	if (report.verdict === "unused") return Option.some({
+		...at,
+		rule: "unused-override",
+		message: `Every package resolves the same way without the override ${report.key}. Remove it.`
+	});
+	if (report.verdict === "verify") return Option.some({
+		...at,
+		rule: "removable-override",
+		message: `Removing the override ${report.key} changes ${describeChanges(report)} without new peer issues or advisories. Remove it and run verify.`
+	});
+	return Option.none();
+};
+// src/override-resolution.ts
+const VerdictSchema = Schema.Literals([
+	"unused",
+	"keep",
+	"verify"
+]);
+const PackageChangeSchema = Schema.Struct({
+	name: Schema.String,
+	before: Schema.Array(Schema.String),
+	after: Schema.Array(Schema.String)
+});
+Schema.Struct({
+	key: Schema.String,
+	verdict: VerdictSchema,
+	changes: Schema.Array(PackageChangeSchema),
+	peerContextsChanged: Schema.Boolean,
+	peerIssues: Schema.Array(Schema.String),
+	advisories: Schema.Array(Schema.String)
+});
+const PeerParentSchema = Schema.Struct({
+	name: Schema.String,
+	version: Schema.String
+});
+const PeerIssueSchema = Schema.Struct({
+	parents: Schema.Array(PeerParentSchema),
+	wantedRange: Schema.String,
+	foundVersion: Schema.optionalKey(Schema.String)
+});
+const ProjectPeerIssuesSchema = Schema.Struct({
+	bad: Schema.Record(Schema.String, Schema.Array(PeerIssueSchema)),
+	missing: Schema.Record(Schema.String, Schema.Array(PeerIssueSchema)),
+	conflicts: Schema.Array(Schema.String)
+});
+const PeerIssuesLog = Schema.fromJsonString(Schema.Struct({
+	name: Schema.Literal("pnpm:peer-dependency-issues"),
+	issuesByProjects: Schema.Record(Schema.String, ProjectPeerIssuesSchema)
+}));
+const AdvisorySchema = Schema.Struct({
+	module_name: Schema.String,
+	github_advisory_id: Schema.String
+});
+const AuditReport = Schema.fromJsonString(Schema.Struct({ advisories: Schema.Record(Schema.String, AdvisorySchema) }));
+const SCOPE_PREFIX = "@";
+const NAME_START = 0;
+const SEPARATOR_LENGTH = 1;
+const PEER_CONTEXT_START = "(";
+const sorted = (values) => Array.sort(Array.dedupe(values), Order.String);
+const describeIssue = (project, kind) => ([peer, issues]) => pipe(issues, Array.map((issue) => {
+	const dependent = Option.match(Array.last(issue.parents), {
+		onNone: () => project,
+		onSome: (parent) => `${parent.name}@${parent.version}`
+	});
+	const found = Option.getOrElse(Option.fromUndefinedOr(issue.foundVersion), () => "none");
+	return `${project}: ${kind} peer ${peer}@${issue.wantedRange} of ${dependent}, found ${found}`;
+}));
+const issuesOfProject = ([project, issues]) => [
+	...pipe(Record.toEntries(issues.bad), Array.flatMap(describeIssue(project, "unmet"))),
+	...pipe(Record.toEntries(issues.missing), Array.flatMap(describeIssue(project, "missing"))),
+	...pipe(issues.conflicts, Array.map((peer) => `${project}: conflicting peer ${peer}`))
+];
+const peerIssuesIn = (output) => sorted(pipe(String$1.split(output, "\n"), Array.map((line) => Schema.decodeOption(PeerIssuesLog)(line)), Array.getSomes, Array.flatMap((log) => pipe(Record.toEntries(log.issuesByProjects), Array.flatMap(issuesOfProject)))));
+const advisoriesIn = (output) => Option.match(Schema.decodeOption(AuditReport)(output), {
+	onNone: () => [],
+	onSome: (report) => sorted(pipe(Record.values(report.advisories), Array.map((advisory) => `${advisory.module_name} ${advisory.github_advisory_id}`)))
+});
+const separatorOf = (key) => {
+	if (!String$1.startsWith(SCOPE_PREFIX)(key)) return String$1.indexOf(SCOPE_PREFIX)(key);
+	return pipe(String$1.slice(SEPARATOR_LENGTH)(key), String$1.indexOf(SCOPE_PREFIX), Option.map((index) => index + SEPARATOR_LENGTH));
+};
+const withoutPeerContext = (version) => Option.match(String$1.indexOf(PEER_CONTEXT_START)(version), {
+	onNone: () => version,
+	onSome: (start) => String$1.slice(NAME_START, start)(version)
+});
+const packageOf = (key) => Option.map(separatorOf(key), (separator) => [String$1.slice(NAME_START, separator)(key), withoutPeerContext(String$1.slice(separator + SEPARATOR_LENGTH)(key))]);
+const keysOf = (node) => {
+	if (!isMap(node)) return [];
+	return pipe(node.items, Array.flatMap((pair) => {
+		if (isScalar(pair.key)) return [String(pair.key.value)];
+		return [];
+	}));
+};
+const lockfileKeysOf = (lockfile, section) => pipe(parseAllDocuments(lockfile), Array.flatMap((document) => keysOf(document.get(section))));
+const resolutionOf = (findings) => (lockfile) => {
+	const snapshots = lockfileKeysOf(lockfile, "snapshots");
+	const packages = Array.getSomes(pipe([...lockfileKeysOf(lockfile, "packages"), ...snapshots], Array.map((key) => packageOf(key))));
+	const versions = Record.map(Array.groupBy(packages, ([name]) => name), (entries) => sorted(pipe(entries, Array.map(([, version]) => version))));
+	return {
+		...findings,
+		versions,
+		snapshots: sorted(snapshots)
+	};
+};
+const changesBetween = (baseline, candidate) => pipe(sorted([...Record.keys(baseline.versions), ...Record.keys(candidate.versions)]), Array.map((name) => ({
+	name,
+	before: baseline.versions[name] ?? [],
+	after: candidate.versions[name] ?? []
+})), Array.filter((change) => Array.join(change.before, " ") !== Array.join(change.after, " ")));
+const growsThePackageSet = (change) => change.after.length > change.before.length;
+const needsTheOverride = (found) => pipe(found.changes, Array.some((change) => growsThePackageSet(change))) || Array.isReadonlyArrayNonEmpty(found.peerIssues) || Array.isReadonlyArrayNonEmpty(found.advisories);
+const judge = (baseline) => (key, candidate) => {
+	const changes = changesBetween(baseline, candidate);
+	const peerIssues = Array.difference(candidate.peerIssues, baseline.peerIssues);
+	const advisories = Array.difference(candidate.advisories, baseline.advisories);
+	const peerContextsChanged = Array.join(baseline.snapshots, " ") !== Array.join(candidate.snapshots, " ");
+	const found = {
+		key,
+		changes,
+		peerContextsChanged,
+		peerIssues,
+		advisories
+	};
+	if (!Array.isReadonlyArrayNonEmpty(changes) && !peerContextsChanged) return {
+		...found,
+		verdict: "unused"
+	};
+	if (needsTheOverride(found)) return {
+		...found,
+		verdict: "keep"
+	};
+	return {
+		...found,
+		verdict: "verify"
+	};
+};
+const OVERRIDES = "overrides";
+const BASELINE_PROBE = "msch-baseline-probe";
+const REMOVED_DEPENDENCY = "-";
+const overrideKeysOf = (manifest) => {
+	const lineCounter = new LineCounter();
+	const overrides = parseDocument(manifest, { lineCounter }).get(OVERRIDES);
+	if (!isMap(overrides)) return [];
+	return pipe(overrides.items, Array.flatMap((pair) => {
+		const { key } = pair;
+		if (!isScalar(key)) return [];
+		return pipe(Option.fromNullishOr(key.range), Option.map(([start]) => {
+			const { line, col } = lineCounter.linePos(start);
+			return {
+				key: String(key.value),
+				line,
+				column: col
+			};
+		}), Option.toArray);
+	}));
+};
+const withoutOverride = (key) => (manifest) => {
+	const document = parseDocument(manifest);
+	document.deleteIn([OVERRIDES, key]);
+	return document.toString();
+};
+const withBaselineProbe = (manifest) => {
+	const document = parseDocument(manifest);
+	document.setIn([OVERRIDES, BASELINE_PROBE], REMOVED_DEPENDENCY);
+	return document.toString();
+};
+// src/overrides.ts
+const WORKSPACE_FILE = "pnpm-workspace.yaml";
+const LOCKFILE$1 = "pnpm-lock.yaml";
+const RESOLUTION_FILES = [
+	"*package.json",
+	WORKSPACE_FILE,
+	LOCKFILE$1,
+	".npmrc",
+	"patches/*"
+];
+const RESOLUTION_CONCURRENCY = 4;
+const SUCCEEDED = 0;
+const taggedError = Schema.TaggedError;
+var OverrideResolutionFailed = class extends taggedError()("OverrideResolutionFailed", {
+	override: Schema.String,
+	output: Schema.String
+}) {};
+const textOf = (stream) => stream.pipe(Stream.decodeText(), Stream.mkString);
+const resolveIn = Effect.fn("resolveIn")(function* resolveIn(directory, override) {
+	const handle = yield* ChildProcess.make("vp", [
+		"install",
+		"--lockfile-only",
+		"--ignore-scripts",
+		"--",
+		"--reporter=ndjson"
+	], {
+		cwd: directory,
+		env: { CI: "true" },
+		extendEnv: true,
+		stdin: "ignore"
+	});
+	const [output, status] = yield* Effect.all([textOf(handle.all), handle.exitCode], { concurrency: "unbounded" });
+	if (Number(status) !== SUCCEEDED) return yield* OverrideResolutionFailed.make({
+		override,
+		output
+	});
+	return output;
+});
+const auditIn = Effect.fn("auditIn")(function* auditIn(directory) {
+	const handle = yield* ChildProcess.make("vp", [
+		"pm",
+		"audit",
+		"--json"
+	], {
+		cwd: directory,
+		extendEnv: true,
+		stdin: "ignore"
+	});
+	const [report] = yield* Effect.all([textOf(handle.stdout), handle.exitCode], { concurrency: "unbounded" });
+	return advisoriesIn(report);
+}, Effect.scoped);
+const trackedResolutionFiles = Effect.fn("trackedResolutionFiles")(function* trackedFiles(root) {
+	const handle = yield* ChildProcess.make("git", [
+		"ls-files",
+		"-z",
+		"--",
+		...RESOLUTION_FILES
+	], { cwd: root });
+	const listed = yield* textOf(handle.stdout);
+	return pipe(String$1.split(listed, "\0"), Array.filter(String$1.isNonEmpty));
+}, Effect.scoped);
+const copyFiles = Effect.fn("copyFiles")(function* copyFiles(workspace, directory) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const copyOne = (file) => {
+		const target = path.join(directory, file);
+		const copy = fs.copyFile(path.join(workspace.root, file), target);
+		return fs.makeDirectory(path.dirname(target), { recursive: true }).pipe(Effect.andThen(copy));
+	};
+	yield* Effect.forEach(workspace.files, copyOne, { discard: true });
+});
+const resolutionWith = Effect.fn("resolutionWith")(function* resolutionWith(workspace, override, manifest) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const directory = yield* fs.makeTempDirectoryScoped({ prefix: "msch-overrides-" });
+	yield* copyFiles(workspace, directory);
+	yield* fs.writeFileString(path.join(directory, WORKSPACE_FILE), manifest);
+	const output = yield* resolveIn(directory, override);
+	const lockfile = yield* fs.readFileString(path.join(directory, LOCKFILE$1));
+	yield* Effect.annotateCurrentSpan({ "msch.override": override });
+	const advisories = yield* auditIn(directory);
+	return resolutionOf({
+		peerIssues: peerIssuesIn(output),
+		advisories
+	})(lockfile);
+}, Effect.scoped);
+const problemsFor = Effect.fn("problemsFor")(function* problemsFor(root, manifest, keys) {
+	const path = yield* Path.Path;
+	const workspace = {
+		root,
+		files: yield* trackedResolutionFiles(root),
+		manifest
+	};
+	const baseline = yield* resolutionWith(workspace, BASELINE_PROBE, withBaselineProbe(manifest));
+	const judgeAgainstBaseline = judge(baseline);
+	const file = path.join(root, WORKSPACE_FILE);
+	const problemOf = (located) => resolutionWith(workspace, located.key, withoutOverride(located.key)(manifest)).pipe(Effect.map((candidate) => overrideProblem({
+		...located,
+		file
+	})(judgeAgainstBaseline(located.key, candidate))));
+	const problems = yield* Effect.forEach(keys, problemOf, { concurrency: RESOLUTION_CONCURRENCY });
+	return Array.getSomes(problems);
+});
+/** @internal */
+const checkOverrides = Effect.fn("checkOverrides")(function* checkOverrides(root) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const manifest = yield* fs.readFileString(path.join(root, WORKSPACE_FILE)).pipe(Effect.option);
+	const keys = Option.match(manifest, {
+		onNone: () => [],
+		onSome: overrideKeysOf
+	});
+	if (Option.isNone(manifest) || !Array.isReadonlyArrayNonEmpty(keys)) return [];
+	return yield* problemsFor(root, manifest.value, keys);
+});
+// src/python.ts
+const PYTHON_FILE = /(?:\.(?:py|pyi|pyw|pyx|ipynb)|(?:^|\/)(?:pyproject\.toml|uv\.lock|uv\.toml|poetry\.lock|Pipfile|Pipfile\.lock|setup\.cfg|tox\.ini|pytest\.ini|\.python-version|requirements[^/]*\.txt))$/u;
+const SCANNED_FILE = /(?:\.(?:[cm]?[jt]sx?|jsonc?|toml|ya?ml|sh|bash|zsh|fish|rs|cs|go|mk)|(?:^|\/)(?:Dockerfile[^/]*|Makefile|justfile|\.tool-versions|[^./][^./]*))$/u;
+const LOCKFILE = /(?:^|\/)(?:[^/]*\.lock|[^/]*-lock\.(?:json|ya?ml))$/u;
+const TOOL_VERSIONS = /(?:^|\/)(?:\.?mise(?:\.[^/]+)?\.toml|\.tool-versions)$/u;
+const COMMAND_PATTERNS = [
+	/(?<![\w./@-])python[\d.]*[ \t]+(?:[-"'$./]|\S+\.py\b)/gu,
+	/(?<![\w./@-])pip3?[ \t]+(?:install|uninstall|download|freeze|wheel|compile|sync)\b/gu,
+	/(?<![\w./@-])pipx[ \t]+(?:run|install|inject|upgrade)\b/gu,
+	/(?<![\w./@-])uvx[ \t]+[^\s=:,;)|&]/gu,
+	/(?<![\w./@-])uv[ \t]+(?:run|sync|lock|pip|tool|venv|add|remove|python|export|build|publish|init|tree|cache|self)\b/gu,
+	/(?<![\w./@-])poetry[ \t]+(?:run|install|add|lock|build|publish|shell|export)\b/gu,
+	/(?:\bcommand["']?\s*[:=]\s*|(?:\bspawn\w*|\bexec\w*|\bexeca|Command::new|ChildProcess\.make|\$)\(\s*)["'`](?:python[\d.]*|pip3?|pipx|uvx?|poetry)["'`]/gu,
+	/\buses:\s*["']?(?:actions\/setup-python|astral-sh\/setup-uv|astral-sh\/ruff-action|pypa\/[\w.-]+|snok\/install-poetry|abatilo\/actions-poetry|conda-incubator\/setup-miniconda|mamba-org\/setup-micromamba|pdm-project\/setup-pdm)\b/gu
+];
+const TOOL_PATTERNS = [/^[ \t]*["']?(?:python|uv|pipx|poetry|ruff|pdm|hatch|pipx:[^"'\s=]+)["']?[ \t]*(?:=|[ \t]+\S)/gmu];
+const READ_CONCURRENCY = 64;
+const FIRST_LINE = 1;
+const FIRST_COLUMN = 1;
+const WHOLE_MATCH = 0;
+const FILE_RULE = "python-file";
+const COMMAND_RULE = "python-command";
+const fileProblem = ({ file }) => ({
+	file,
+	line: FIRST_LINE,
+	column: FIRST_COLUMN,
+	rule: FILE_RULE,
+	message: "Python is not used in this repository. Replace this file with TypeScript or Rust."
+});
+const patternsFor = (name) => {
+	if (TOOL_VERSIONS.test(name)) return [...COMMAND_PATTERNS, ...TOOL_PATTERNS];
+	return COMMAND_PATTERNS;
+};
+const commandProblem = ({ file }, source) => (found) => ({
+	file,
+	...positionOf(source)(found.index ?? WHOLE_MATCH),
+	rule: COMMAND_RULE,
+	message: `Python is not used in this repository. Remove \`${String$1.trim(found[WHOLE_MATCH])}\` and do the work in TypeScript or Rust.`
+});
+const commandProblems = (entry, source) => pipe(patternsFor(entry.name), Array.flatMap((pattern) => Array.fromIterable(String$1.matchAll(pattern)(source))), Array.map(commandProblem(entry, source)));
+const isPython = ({ name }) => PYTHON_FILE.test(name);
+const isScanned = (entry) => !isPython(entry) && SCANNED_FILE.test(entry.name) && !LOCKFILE.test(entry.name);
+/** @internal */
+const checkPython = Effect.fn("checkPython")(function* checkPython(root) {
+	const files = yield* RepositoryFiles;
+	const names = yield* files.listedFiles(root);
+	const listed = pipe(names, Array.map((name) => ({
+		name,
+		file: files.join(root, name)
+	})));
+	const problemsIn = (entry) => files.readFile(entry.file).pipe(Effect.map(Option.match({
+		onNone: () => [],
+		onSome: (source) => commandProblems(entry, source)
+	})));
+	const scanned = yield* Effect.forEach(pipe(listed, Array.filter(isScanned)), problemsIn, { concurrency: READ_CONCURRENCY });
+	const present = yield* Effect.filter(pipe(listed, Array.filter(isPython)), ({ file }) => files.exists(file));
+	return [...pipe(present, Array.map(fileProblem)), ...Array.flatten(scanned)];
+});
+// src/runtime.ts
+const reportFailure = (cause) => Effect.gen(function* report() {
+	const stdio = yield* Stdio.Stdio;
+	if (Cause.findErrorOption(cause).pipe(Option.exists(Schema.is(ProblemsFound)))) return;
+	yield* Stream.make(`${Cause.pretty(cause)}\n`).pipe(Stream.run(stdio.stderr()), Effect.orDie);
+});
+const tracing = Otlp.layerFromConfig({ resource: { serviceName: "msch" } }).pipe(Layer.provide(OtlpSerialization.layerJson), Layer.provide(FetchHttpClient.layer));
+const runCli = (program) => {
+	const services = Layer.mergeAll(nodeRepositoryFiles, tracing).pipe(Layer.provideMerge(layer));
+	const main = Layer.build(services).pipe(Effect.flatMap((context) => Effect.provideContext(program.pipe(Effect.tapCause(reportFailure)), context)), Effect.scoped);
+	runMain(main, { disableErrorReporting: true });
+};
+// src/cli.ts
+const NO_PROBLEMS = 0;
+const reportText = (root, problems) => Effect.gen(function* report() {
+	const files = yield* RepositoryFiles;
+	const format = formatProblem((file) => files.relative(root, file));
+	yield* writeStdout(pipe(problems, Array.map((problem) => `${format(problem)}\n`), Array.join("")));
+	if (problems.length > NO_PROBLEMS) return yield* ProblemsFound.make({ count: problems.length });
+	return yield* Effect.void;
+});
+runCli(Effect.gen(function* msch() {
+	const stdio = yield* Stdio.Stdio;
+	const files = yield* RepositoryFiles;
+	const args = yield* stdio.args;
+	const root = files.resolve(".");
+	const found = yield* Effect.all([
+		checkRepository(root),
+		checkOverrides(root),
+		checkHiddenUnicode(root),
+		checkPython(root)
+	], { concurrency: "unbounded" });
+	const problems = sortProblems(Array.flatten(found));
+	if (args.includes("--json")) {
+		const text = yield* Schema.encodeEffect(Schema.fromJsonString(ProblemList))(problems);
+		return yield* writeStdout(text);
+	}
+	return yield* reportText(root, problems);
+}));
+export {};
+
+//# sourceMappingURL=cli.mjs.map