@r_masseater/msch 0.5.1 → 0.6.0

package/dist/cli.mjs

@@ -1,11 +1,10 @@
 #!/usr/bin/env node
-import { $ as isSatisfiesExpression, 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 isTypeLiteralNode, b as resolvedSymbol, c as childrenOf, ct as isVariableDeclaration, d as declarationsOf, et as isSignatureDeclaration, f as descendantsOf, g as isTypeDeclaration, h as isGenericDeclaration, i as formatProblem, it as isTypeAliasDeclaration, j as IndexKind, k as nodeRepositoryFiles, l as columnOf, lt as isVariableDeclarationList, m as isExternalDeclaration, n as ProblemList, nt as isSpreadElement, o as sortProblems, ot as isTypeReferenceNode, p as importedModulesOf, q as isModuleDeclaration, rt as isStringLiteral, s as NODE_MODULES_SEGMENT, st as isUnionTypeNode, tt as isSourceFile, u as contains, ut as isVariableStatement, v as propertyNamesOf, w as NODE_MODULES, x as symbolAt, y as referencedSymbols, z as isBinaryExpression } from "./cli-contract-CkYucdU4.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 { $ as isObjectLiteralExpression, A as nodeServicesLayer, B as isBinaryExpression, C as MANIFEST_FILE, D as workspaceDependencies, E as readManifest, F as getJSDocTags, G as isExportDeclaration, H as isClassDeclaration, I as getLeadingCommentRanges, J as isInterfaceDeclaration, K as isIdentifier, L as getNameOfDeclaration, M as IndexKind, N as InternalSymbolName, O as RepositoryFiles, P as SyntaxKind, Q as isNumericLiteral, R as getTextOfJSDocComment, S as uniqueByReference, T as dependencyEntries, U as isElementAccessExpression, V as isCallExpression, W as isEnumDeclaration, X as isModuleDeclaration, Y as isModuleBlock, Z as isNewExpression, _ as lineOf, a as problemAt, at as isSpreadElement, b as resolvedSymbol, c as childrenOf$1, ct as isTypeLiteralNode, d as declarationsOf, dt as isVariableDeclaration, et as isPropertyAccessExpression, f as descendantsOf, ft as isVariableDeclarationList, g as isTypeDeclaration, h as isGenericDeclaration, i as formatProblem, it as isSourceFile, j as API, k as nodeRepositoryFiles, l as columnOf, lt as isTypeReferenceNode, m as isExternalDeclaration, n as ProblemList, nt as isSatisfiesExpression, o as sortProblems, ot as isStringLiteral, p as importedModulesOf, pt as isVariableStatement, q as isImportDeclaration, rt as isSignatureDeclaration, s as NODE_MODULES_SEGMENT, st as isTypeAliasDeclaration, tt as isPropertyAssignment, u as contains, ut as isUnionTypeNode, v as propertyNamesOf, w as NODE_MODULES, x as symbolAt, y as referencedSymbols, z as isArrayLiteralExpression } from "./cli-contract-DpQurUwC.mjs";
+import { Array, Cause, Effect, FileSystem, Function, HashMap, HashSet, Layer, Number as Number$1, Option, Order, Path, Predicate, Record, Result, Schema, Stdio, Stream, String as String$1, pipe } from "effect";
 import { ChildProcess } from "effect/process";
 import { resolveConfigFromFile } from "vite-plus";
 import { LineCounter, isMap, isScalar, parseAllDocuments, parseDocument } from "yaml";
-import { runMain } from "@effect/platform-node/NodeRuntime";
+import { runMain } from "@effect/platform-node-shared/NodeRuntime";
 import { FetchHttpClient } from "effect/http";
 import { Otlp, OtlpSerialization } from "effect/observability";
 // src/slots.ts
@@ -87,7 +86,7 @@ const valueText = (value) => {
 const formatValues = (values) => pipe(values, Array.map(valueText), Array.join(" | "));
 // src/flows.ts
 const SCOPE_PREFIX$1 = "@";
-const SCOPED_SEGMENTS = 2;
+const SCOPED_SEGMENTS$1 = 2;
 const UNSCOPED_SEGMENTS = 1;
 const MODULE_PREFIX = /^".*?"\./u;
 const packageOf$1 = (fileName) => {
@@ -96,7 +95,7 @@ const packageOf$1 = (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("/"));
+	if (String$1.startsWith(SCOPE_PREFIX$1)(afterModules)) return pipe(Array.take(segments, SCOPED_SEGMENTS$1), Array.join("/"));
 	return pipe(Array.take(segments, UNSCOPED_SEGMENTS), Array.join("/"));
 };
 const externalDeclarationOf = (context) => (symbol) => Array.findFirst(declarationsOf(symbol), (declaration) => isExternalDeclaration(context.program)(declaration));
@@ -457,7 +456,7 @@ const derivationScopeOf = (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)));
+	const nested = pipe(childrenOf$1(node), Array.flatMap((child) => sitesUnder(checker)(child)));
 	if (Array.isReadonlyArrayNonEmpty(nested)) return nested;
 	return siteValuesOf(checker)(node).pipe(Option.map((values) => ({
 		node,
@@ -796,10 +795,10 @@ const checkRepository = Effect.fn("checkRepository")(function* checkRepository(r
 	]);
 }, Effect.scoped);
 // src/text-position.ts
-const START$1 = 0;
+const START$2 = 0;
 const FIRST_COLUMN$1 = 1;
 const positionOf = (source) => (index) => {
-	const before = pipe(source, String$1.slice(START$1, index), String$1.split("\n"));
+	const before = pipe(source, String$1.slice(START$2, index), String$1.split("\n"));
 	return {
 		line: before.length,
 		column: pipe(Array.last(before), Option.match({
@@ -811,17 +810,17 @@ const positionOf = (source) => (index) => {
 // 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 START$1 = 0;
 const HEX = 16;
 const CODE_POINT_WIDTH = 4;
-const READ_CONCURRENCY$2 = 64;
+const READ_CONCURRENCY$3 = 64;
 const RULE$1 = "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 hexOf = (character) => pipe(String$1.codePointAt(START$1)(character), Option.getOrElse(() => START$1), (code) => code.toString(HEX), String$1.toUpperCase, String$1.padStart(CODE_POINT_WIDTH, "0"));
 const problemOf = (file, source) => (found) => {
-	const hex = hexOf(found[START]);
+	const hex = hexOf(found[START$1]);
 	return {
 		file,
-		...positionOf(source)(found.index ?? START),
+		...positionOf(source)(found.index ?? START$1),
 		rule: RULE$1,
 		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}.`
 	};
@@ -840,32 +839,447 @@ const checkHiddenUnicode = Effect.fn("checkHiddenUnicode")(function* checkHidden
 			onNone: () => [],
 			onSome: (source) => problemsIn(file, source)
 		})));
-	}, { concurrency: READ_CONCURRENCY$2 });
+	}, { concurrency: READ_CONCURRENCY$3 });
 	return Array.flatten(found);
 });
-// src/nested-docs.ts
-const RULE = "nested-docs";
-const SEPARATOR = "/";
+// src/import-graph.ts
+const RELATIVE = /^\.\.?(?:\/|$)/u;
+const SUBPATH_IMPORT = "#";
+const WILDCARD = "*";
+const SCOPE = "@";
+const SEPARATOR$3 = "/";
+const SOURCE_SUFFIXES = [
+	"",
+	".ts",
+	".tsx",
+	"/index.ts"
+];
+const SCOPED_SEGMENTS = 2;
+const PLAIN_SEGMENTS = 1;
+const ImportsField = Schema.Struct({ imports: Schema.optional(Schema.Record(Schema.String, Schema.String)) });
+const decodeImports = Schema.decodeOption(Schema.fromJsonString(ImportsField));
+const packageNameOf = (specifier) => {
+	const segments = String$1.split(specifier, SEPARATOR$3);
+	if (String$1.startsWith(SCOPE)(specifier)) return pipe(segments, Array.take(SCOPED_SEGMENTS), Array.join(SEPARATOR$3));
+	return pipe(segments, Array.take(PLAIN_SEGMENTS), Array.join(SEPARATOR$3));
+};
+const literalText = (specifier) => pipe(Option.liftPredicate(specifier, isStringLiteral), Option.map((literal) => literal.text));
+const runtimeSpecifierOf = (statement) => {
+	if (isImportDeclaration(statement)) {
+		const typeOnly = pipe(Option.fromUndefinedOr(statement.importClause), Option.exists((clause) => clause.phaseModifier === SyntaxKind.TypeKeyword));
+		return Option.filter(literalText(statement.moduleSpecifier), () => !typeOnly);
+	}
+	if (isExportDeclaration(statement) && !statement.isTypeOnly) return Option.flatMap(Option.fromUndefinedOr(statement.moduleSpecifier), literalText);
+	return Option.none();
+};
+const specifiersIn = (api, file, text) => {
+	const retained = api.createSourceFile(file, text);
+	const found = pipe(retained.sourceFile.statements, Array.fromIterable, Array.map(runtimeSpecifierOf));
+	retained.dispose();
+	return Array.getSomes(found);
+};
+const subpathTarget = (imports, specifier) => pipe(Record.toEntries(imports), Array.findFirst(([pattern, target]) => {
+	if (!String$1.endsWith(WILDCARD)(pattern)) return Option.liftPredicate(target, () => pattern === specifier);
+	const prefix = String$1.replace(WILDCARD, "")(pattern);
+	return Option.liftPredicate(String$1.replace(WILDCARD, String$1.replace(prefix, "")(specifier))(target), () => String$1.startsWith(prefix)(specifier));
+}));
+const existingSource = Effect.fn("existingSource")(function* existingSource(base) {
+	const files = yield* RepositoryFiles;
+	const found = yield* pipe(SOURCE_SUFFIXES, Effect.forEach((suffix) => {
+		const candidate = `${base}${suffix}`;
+		return files.isDirectory(candidate).pipe(Effect.map((directory) => Option.liftPredicate(candidate, () => Option.exists(directory, (isDirectory) => !isDirectory))));
+	}));
+	return Array.head(Array.getSomes(found));
+});
+const localFile = Effect.fn("localFile")(function* localFile({ directory, imports }, from, specifier) {
+	const files = yield* RepositoryFiles;
+	if (RELATIVE.test(specifier)) return yield* existingSource(files.resolve(files.dirname(from), specifier));
+	const target = subpathTarget(imports, specifier);
+	if (Option.isNone(target)) return Option.none();
+	return yield* existingSource(files.resolve(directory, target.value));
+});
+const referenceOf = (graph, from, specifier) => {
+	if (RELATIVE.test(specifier) || String$1.startsWith(SUBPATH_IMPORT)(specifier)) return localFile(graph, from, specifier).pipe(Effect.map(Option.map(Result.succeed)));
+	const name = packageNameOf(specifier);
+	return Effect.succeedSome(Result.fail(name));
+};
+const referencesIn = Effect.fn("referencesIn")(function* referencesIn(graph, file) {
+	const text = yield* (yield* RepositoryFiles).readFile(file);
+	const specifiers = Option.match(text, {
+		onNone: () => [],
+		onSome: (source) => specifiersIn(graph.api, file, source)
+	});
+	const references = yield* pipe(specifiers, Effect.forEach((specifier) => referenceOf(graph, file, specifier)));
+	const found = Array.getSomes(references);
+	return {
+		packages: Array.getFailures(found),
+		sources: Array.getSuccesses(found)
+	};
+});
+const packagesFrom = (graph, walk) => Array.match(walk.pending, {
+	onEmpty: () => Effect.succeed(walk.packages),
+	onNonEmpty: ([next, ...rest]) => {
+		if (HashSet.has(walk.visited, next)) return packagesFrom(graph, {
+			...walk,
+			pending: rest
+		});
+		return referencesIn(graph, next).pipe(Effect.flatMap(({ packages, sources }) => packagesFrom(graph, {
+			pending: [...rest, ...sources],
+			visited: HashSet.add(walk.visited, next),
+			packages: HashSet.union(walk.packages, HashSet.fromIterable(packages))
+		})));
+	}
+});
+/** @internal */
+const packagesByEntry = Effect.fn("packagesByEntry")(function* packagesByEntry(api, directory, entries) {
+	const files = yield* RepositoryFiles;
+	const manifest = yield* files.readFile(files.join(directory, MANIFEST_FILE));
+	const graph = {
+		api,
+		directory,
+		imports: pipe(manifest, Option.flatMap(decodeImports), Option.flatMap((field) => Option.fromUndefinedOr(field.imports)), Option.getOrElse(() => ({})))
+	};
+	return yield* pipe(entries, Effect.forEach((entry) => packagesFrom(graph, {
+		pending: [entry],
+		visited: HashSet.empty(),
+		packages: HashSet.empty()
+	}).pipe(Effect.map((packages) => [entry, packages]))));
+});
+// src/installed-closure.ts
+const EMPTY = 0;
+const DependencyMap = Schema.optional(Schema.Record(Schema.String, Schema.String));
+const PeerMetaEntry = Schema.Struct({ optional: Schema.optional(Schema.Boolean) });
+const PeerMeta = Schema.optional(Schema.Record(Schema.String, PeerMetaEntry));
+const InstalledManifest = Schema.Struct({
+	dependencies: DependencyMap,
+	optionalDependencies: DependencyMap,
+	peerDependencies: DependencyMap,
+	peerDependenciesMeta: PeerMeta
+});
+const decodeManifest = Schema.decodeOption(Schema.fromJsonString(InstalledManifest));
+const keysOf$1 = (map) => pipe(Option.fromUndefinedOr(map), Option.map(Record.keys), Option.getOrElse(() => []));
+const isOptionalPeer = (manifest, name) => pipe(Option.fromUndefinedOr(manifest.peerDependenciesMeta), Option.flatMap(Record.get(name)), Option.exists((meta) => meta.optional === true));
+const installedNames = (manifest) => [
+	...keysOf$1(manifest.dependencies),
+	...keysOf$1(manifest.optionalDependencies),
+	...pipe(keysOf$1(manifest.peerDependencies), Array.filter((name) => !isOptionalPeer(manifest, name)))
+];
+const childrenOf = Effect.fn("childrenOf")(function* childrenOf(directory) {
+	const files = yield* RepositoryFiles;
+	const text = yield* files.readFile(files.join(directory, MANIFEST_FILE));
+	return pipe(text, Option.flatMap(decodeManifest), Option.map(installedNames), Option.getOrElse(() => []), Array.map((child) => [directory, child]));
+});
+const resolveFrom = (from, name) => Effect.gen(function* resolvePackage() {
+	const files = yield* RepositoryFiles;
+	const candidate = files.join(from, NODE_MODULES, name);
+	if (yield* files.exists(files.join(candidate, "package.json"))) {
+		const real = yield* files.realPath(candidate);
+		return Option.some(real);
+	}
+	const parent = files.dirname(from);
+	if (parent === from) return Option.none();
+	return yield* resolveFrom(parent, name);
+});
+const unseen = (from, name, seen) => resolveFrom(from, name).pipe(Effect.map(Option.filter((directory) => !HashSet.has(seen, directory))));
+const closureOf = (provided, collect) => Array.match(collect.pending, {
+	onEmpty: () => Effect.succeed(collect.seen),
+	onNonEmpty: ([[from, name], ...rest]) => {
+		if (HashSet.has(provided, name)) return closureOf(provided, {
+			...collect,
+			pending: rest
+		});
+		return unseen(from, name, collect.seen).pipe(Effect.flatMap((resolved) => {
+			if (Option.isNone(resolved)) return closureOf(provided, {
+				...collect,
+				pending: rest
+			});
+			return childrenOf(resolved.value).pipe(Effect.flatMap((children) => closureOf(provided, {
+				pending: [...rest, ...children],
+				seen: HashSet.add(collect.seen, resolved.value)
+			})));
+		}));
+	}
+});
+const directorySize = (directory) => Effect.gen(function* sizeOfDirectory() {
+	const files = yield* RepositoryFiles;
+	const names = yield* files.readDirectory(directory);
+	const entries = pipe(names, Array.filter((name) => name !== NODE_MODULES), Array.map((name) => files.join(directory, name)));
+	const sizes = yield* pipe(entries, Effect.forEach((entry) => files.isDirectory(entry).pipe(Effect.flatMap((kind) => {
+		if (Option.isNone(kind)) return Effect.succeed(EMPTY);
+		if (kind.value) return directorySize(entry);
+		return files.fileSize(entry);
+	}))));
+	return Number$1.sumAll(sizes);
+});
+const installedClosure = ({ provided, from, name }) => closureOf(provided, {
+	pending: [[from, name]],
+	seen: HashSet.empty()
+});
+const installedSize = (directory) => {
+	if (String$1.includes(`/node_modules/`)(directory)) return directorySize(directory);
+	return Effect.succeed(EMPTY);
+};
+// src/public-entries.ts
+const SOURCE = /\.[cm]?tsx?$/u;
+const BUILT = /\.(?:d\.)?[cm]?[jt]s$/u;
+const DECLARATION = ".d.";
+const SEPARATOR$2 = "/";
+const ROOT_SUBPATH = ".";
+const BIN_LABEL = "bin";
+const targetsIn = (held) => {
+	if (Predicate.isString(held)) return [held];
+	if (!Predicate.isObject(held)) return [];
+	return pipe(Record.values(held), Array.flatMap(targetsIn));
+};
+const subpathsOf = (exportsField) => {
+	if (!Predicate.isObject(exportsField)) return [[ROOT_SUBPATH, exportsField]];
+	const entries = Record.toEntries(exportsField);
+	if (pipe(entries, Array.some(([key]) => String$1.startsWith(ROOT_SUBPATH)(key)))) return entries;
+	return [[ROOT_SUBPATH, exportsField]];
+};
+const binsOf = (manifest) => {
+	if (Predicate.isString(manifest.bin)) {
+		const name = Option.getOrElse(Option.fromUndefinedOr(manifest.name), () => "");
+		return [[`${BIN_LABEL} ${name}`, manifest.bin]];
+	}
+	if (!Predicate.isObject(manifest.bin)) return [];
+	return pipe(Record.toEntries(manifest.bin), Array.map(([name, target]) => [`${BIN_LABEL} ${name}`, target]));
+};
+const baseNameOf = (target) => pipe(String$1.split(target, SEPARATOR$2), Array.last, Option.getOrElse(() => target), String$1.replace(BUILT, ""));
+const sourceOf = ({ join, packEntries }) => (target) => {
+	if (SOURCE.test(target) && !String$1.includes(DECLARATION)(target)) return Option.some(join(target));
+	const name = baseNameOf(target);
+	return pipe(packEntries, Array.findFirst((entry) => entry.name === name), Option.map((entry) => entry.source));
+};
+const publicEntriesOf = (lookup) => pipe([...subpathsOf(lookup.manifest.exports), ...binsOf(lookup.manifest)], Array.flatMap(([label, held]) => pipe(targetsIn(held), Array.map(sourceOf(lookup)), Array.getSomes, Array.map((source) => ({
+	label,
+	source
+})))), Array.dedupeWith((left, right) => left.label === right.label && left.source === right.source));
+// src/published.ts
 const CONFIG_FILE = "vite.config.ts";
-const FIRST = 1;
-const READ_CONCURRENCY$1 = 64;
-const AGENT_DOCS = /^(?:AGENTS|CLAUDE)(?:\.[^/]+)?\.md$/iu;
-const README = /^README(?:\.[^/]+)?$/iu;
-const Published = Schema.Struct({ publish: Schema.Literal(true) });
-const WorkspaceConfig = Schema.Struct({ msch: Published });
+const SEPARATOR$1 = "/";
+const READ_CONCURRENCY$2 = 16;
+const SOURCE_EXTENSION = /\.[cm]?tsx?$/u;
+const UNIT_BYTES = [
+	["B", 1],
+	["kB", 1e3],
+	["MB", 1e6]
+];
+const SizeText = Schema.TemplateLiteralParser([
+	Schema.Finite,
+	" ",
+	Schema.Literals([
+		"B",
+		"kB",
+		"MB"
+	])
+]);
+const PackEntry = Schema.Union([
+	Schema.String,
+	Schema.Array(Schema.String),
+	Schema.Record(Schema.String, Schema.String)
+]);
+const PackSettings = Schema.Struct({ entry: Schema.optional(PackEntry) });
+const PackList = Schema.Union([PackSettings, Schema.Array(PackSettings)]);
+const isEntryList = Schema.is(Schema.Array(Schema.String));
+const WorkspaceConfig = Schema.Struct({
+	msch: Schema.Struct({ publish: Schema.Struct({ installSize: SizeText }) }),
+	pack: Schema.optional(PackList)
+});
+const PublicManifest = Schema.Struct({ private: Schema.optional(Schema.Literal(false)) });
 const taggedError$2 = Schema.TaggedError;
 var WorkspaceConfigUnreadable = class extends taggedError$2()("WorkspaceConfigUnreadable", { file: Schema.String }) {};
-const isNested = (name) => String$1.includes(SEPARATOR)(name);
-const isPublished = Effect.fn("isPublished")(function* isPublished(root, directory) {
-	const files = yield* RepositoryFiles;
-	const file = files.join(root, directory, CONFIG_FILE);
-	if (!(yield* files.exists(file))) return false;
+const bytesPer = (unit) => pipe(UNIT_BYTES, Array.findFirst(([name]) => name === unit), Option.map(([, bytes]) => bytes), Option.getOrElse(() => NaN));
+const nameOf = (source) => pipe(String$1.split(source, SEPARATOR$1), Array.last, Option.getOrElse(() => source), String$1.replace(SOURCE_EXTENSION, ""));
+const entriesOf = (entry) => {
+	if (Predicate.isString(entry)) return [{
+		name: nameOf(entry),
+		source: entry
+	}];
+	if (isEntryList(entry)) return pipe(entry, Array.map((source) => ({
+		name: nameOf(source),
+		source
+	})));
+	return pipe(Record.toEntries(entry), Array.map(([name, source]) => ({
+		name,
+		source
+	})));
+};
+const packEntriesOf = (pack) => pipe(Option.fromUndefinedOr(pack), Option.map(Array.ensure), Option.getOrElse(() => []), Array.flatMap((setting) => pipe(Option.fromUndefinedOr(setting.entry), Option.match({
+	onNone: () => [],
+	onSome: entriesOf
+}))));
+const settingsIn = Effect.fn("settingsIn")(function* settingsIn(file) {
 	const config = yield* Effect.tryPromise({
 		try: () => resolveConfigFromFile(file),
 		catch: () => WorkspaceConfigUnreadable.make({ file })
 	}).pipe(Effect.option);
-	return pipe(config, Option.flatMap(Schema.decodeUnknownOption(WorkspaceConfig)), Option.isSome);
+	return pipe(config, Option.flatMap(Schema.decodeUnknownOption(WorkspaceConfig)));
+});
+const isPublicPackage = Effect.fn("isPublicPackage")(function* isPublicPackage(directory) {
+	const files = yield* RepositoryFiles;
+	const text = yield* files.readFile(files.join(directory, MANIFEST_FILE));
+	return Option.exists(text, (found) => Option.isSome(Schema.decodeOption(Schema.fromJsonString(PublicManifest))(found)));
+});
+const workspaceOf = (directory, configFile, join) => ({ msch, pack }) => {
+	const [amount, , unit] = msch.publish.installSize;
+	return {
+		directory,
+		configFile,
+		installSize: `${amount} ${unit}`,
+		installBudget: amount * bytesPer(unit),
+		packEntries: pipe(packEntriesOf(pack), Array.map((entry) => ({
+			name: entry.name,
+			source: join(entry.source)
+		})))
+	};
+};
+const publishedIn = Effect.fn("publishedIn")(function* publishedIn(root, configName) {
+	const files = yield* RepositoryFiles;
+	const configFile = files.join(root, configName);
+	const directory = files.dirname(configFile);
+	if (!(yield* isPublicPackage(directory))) return Option.none();
+	const settings = yield* settingsIn(configFile);
+	return pipe(settings, Option.map(workspaceOf(directory, configFile, (source) => files.join(directory, source))));
+});
+/** @internal */
+const publishedWorkspaces = Effect.fn("publishedWorkspaces")(function* publishedWorkspaces(root) {
+	const files = yield* RepositoryFiles;
+	const names = yield* files.listedFiles(root);
+	const configs = pipe(names, Array.filter((name) => files.basename(name) === CONFIG_FILE && String$1.includes(SEPARATOR$1)(name)));
+	const found = yield* Effect.forEach(configs, (name) => publishedIn(root, name), { concurrency: READ_CONCURRENCY$2 });
+	return Array.getSomes(found);
+});
+// src/install-size.ts
+const INSTALL_SIZE = "install-size";
+const STACK_DEPENDENCY = "stack-dependency";
+const STACK_CATALOG = "catalog:stack";
+const BUDGET_KEY = "installSize";
+const DEPENDENCIES_KEY = "\"dependencies\"";
+const LISTED_LARGEST = 5;
+const SIZE_CONCURRENCY = 32;
+const MEGABYTE = 1e6;
+const MEGABYTE_DIGITS = 1;
+const START = 0;
+const SINGLE_ENTRY = 1;
+const megabytes = (bytes) => `${(bytes / MEGABYTE).toFixed(MEGABYTE_DIGITS)} MB`;
+const usageHint = (dependency, entryCount) => {
+	if (!(entryCount > SINGLE_ENTRY && dependency.entries.length > START && dependency.entries.length < entryCount)) return "";
+	return ` (imported only from ${Array.join(dependency.entries, ", ")})`;
+};
+const listed = ({ largest, entryCount }) => pipe(largest, Array.map((dependency) => `${dependency.name} ${megabytes(dependency.size)}${usageHint(dependency, entryCount)}`), Array.join(", "));
+const budgetProblem = Effect.fn("budgetProblem")(function* budgetProblem(overrun) {
+	const files = yield* RepositoryFiles;
+	const { workspace, total } = overrun;
+	const config = yield* files.readFile(workspace.configFile);
+	const source = Option.getOrElse(config, () => "");
+	const index = Option.getOrElse(String$1.indexOf(BUDGET_KEY)(source), () => START);
+	return {
+		file: workspace.configFile,
+		...positionOf(source)(index),
+		rule: INSTALL_SIZE,
+		message: `installing this package adds ${megabytes(total)} of dependencies besides its peers, over the ${workspace.installSize} in msch.publish.installSize. Largest: ${listed(overrun)}. Make a dependency imported only from some entries an optional peer, move one that the installing project already has to peerDependencies, or replace a heavy one. Raise installSize only when none of these applies.`
+	};
+});
+const measure = Effect.fn("measure")(function* measure({ workspace, provided }, direct) {
+	const closures = yield* pipe(direct, Effect.forEach((name) => installedClosure({
+		provided,
+		from: workspace.directory,
+		name
+	}).pipe(Effect.map((packages) => [name, packages]))));
+	const everything = pipe(closures, Array.flatMap(([, packages]) => Array.fromIterable(packages)), HashSet.fromIterable);
+	const measured = yield* Effect.forEach(everything, (found) => installedSize(found).pipe(Effect.map((size) => [found, size])), { concurrency: SIZE_CONCURRENCY });
+	const sizes = HashMap.fromIterable(measured);
+	const sizeOf = (packages) => Number$1.sumAll(pipe(Array.fromIterable(packages), Array.map((found) => Option.getOrElse(HashMap.get(sizes, found), () => START))));
+	return {
+		closures,
+		sizeOf,
+		total: sizeOf(everything)
+	};
+});
+const importersOf = Effect.fn("importersOf")(function* importersOf({ workspace, entries }) {
+	const compiler = yield* typeScriptCompiler;
+	const sources = pipe(entries, Array.map((entry) => entry.source), Array.dedupe);
+	const byEntry = yield* packagesByEntry(compiler.api, workspace.directory, sources);
+	const reached = HashMap.fromIterable(byEntry);
+	return (name) => pipe(entries, Array.filter((entry) => pipe(HashMap.get(reached, entry.source), Option.exists(HashSet.has(name)))), Array.map((entry) => entry.label), Array.dedupe);
+}, Effect.scoped);
+const bySizeDescending = Order.mapInput(Order.flip(Order.Number), (dependency) => dependency.size);
+const sizeProblems = Effect.fn("sizeProblems")(function* sizeProblems(published, direct) {
+	const { closures, sizeOf, total } = yield* measure(published, direct);
+	if (total <= published.workspace.installBudget) return [];
+	const importers = yield* importersOf(published);
+	const largest = pipe(closures, Array.map(([name, packages]) => ({
+		name,
+		size: sizeOf(packages),
+		entries: importers(name)
+	})), Array.sortBy(bySizeDescending), Array.take(LISTED_LARGEST));
+	const entryCount = pipe(published.entries, Array.map((entry) => entry.label), Array.dedupe).length;
+	return [yield* budgetProblem({
+		workspace: published.workspace,
+		total,
+		largest,
+		entryCount
+	})];
+});
+const stackProblems = (file, source, dependencies) => {
+	const section = Option.getOrElse(String$1.indexOf(DEPENDENCIES_KEY)(source), () => START);
+	const rest = String$1.slice(section)(source);
+	return pipe(Record.toEntries(dependencies), Array.filter(([, specifier]) => specifier === STACK_CATALOG), Array.map(([name]) => ({
+		file,
+		...positionOf(source)(section + Option.getOrElse(String$1.indexOf(`"${name}"`)(rest), () => START)),
+		rule: STACK_DEPENDENCY,
+		message: `${name} comes from the stack catalog, so every project that installs this package already has it. Move it to peerDependencies and keep it in devDependencies, so the installing project shares one copy.`
+	})));
+};
+const PublishedManifest = Schema.Struct({
+	name: Schema.optional(Schema.String),
+	dependencies: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+	peerDependencies: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+	exports: Schema.optional(Schema.Unknown),
+	bin: Schema.optional(Schema.Unknown)
 });
+const problemsOf = Effect.fn("problemsOf")(function* problemsOf(workspace, file, source) {
+	const files = yield* RepositoryFiles;
+	const manifest = Schema.decodeOption(Schema.fromJsonString(PublishedManifest))(source);
+	if (Option.isNone(manifest)) return [];
+	const dependencies = Option.getOrElse(Option.fromUndefinedOr(manifest.value.dependencies), () => ({}));
+	const entries = publicEntriesOf({
+		manifest: manifest.value,
+		join: (target) => files.join(workspace.directory, target),
+		packEntries: workspace.packEntries
+	});
+	const provided = HashSet.fromIterable(keysOf$1(manifest.value.peerDependencies));
+	const sized = yield* sizeProblems({
+		workspace,
+		entries,
+		provided
+	}, Record.keys(dependencies));
+	return [...stackProblems(file, source, dependencies), ...sized];
+});
+const workspaceProblems = Effect.fn("workspaceProblems")(function* workspaceProblems(workspace) {
+	const files = yield* RepositoryFiles;
+	const file = files.join(workspace.directory, MANIFEST_FILE);
+	const source = yield* files.readFile(file);
+	return yield* Option.match(source, {
+		onNone: () => Effect.succeed([]),
+		onSome: (text) => problemsOf(workspace, file, text)
+	});
+});
+/** @internal */
+const checkPublishedPackages = Effect.fn("checkPublishedPackages")(function* checkPublishedPackages(root) {
+	const workspaces = yield* publishedWorkspaces(root);
+	const found = yield* pipe(workspaces, Effect.forEach(workspaceProblems));
+	return Array.flatten(found);
+});
+// src/nested-docs.ts
+const RULE = "nested-docs";
+const SEPARATOR = "/";
+const FIRST = 1;
+const READ_CONCURRENCY$1 = 64;
+const AGENT_DOCS = /^(?:AGENTS|CLAUDE)(?:\.[^/]+)?\.md$/iu;
+const README = /^README(?:\.[^/]+)?$/iu;
+const isNested = (name) => String$1.includes(SEPARATOR)(name);
 const problemFor = (file, message) => ({
 	file,
 	line: FIRST,
@@ -874,21 +1288,23 @@ const problemFor = (file, message) => ({
 	message
 });
 const AGENT_DOCS_MESSAGE = "belongs only at the repository root. Move what agents need into the root AGENTS.md and delete this file.";
-const README_MESSAGE = "is allowed below the root only in a workspace published to npm, marked by msch: { publish: true } in its vite.config.ts. Set it there if the workspace is published, or move the content into the root README.md and delete this file.";
-const problemIn = Effect.fn("problemIn")(function* problemIn(root, name) {
+const README_MESSAGE = "is allowed below the root only in a workspace published to npm, marked by msch: { publish: { installSize } } in its vite.config.ts. Set it there if the workspace is published, or move the content into the root README.md and delete this file.";
+const problemIn = Effect.fn("problemIn")(function* problemIn(root, published, name) {
 	const files = yield* RepositoryFiles;
 	const base = files.basename(name);
 	const file = files.join(root, name);
 	if (AGENT_DOCS.test(base)) return Option.some(problemFor(file, `${base} ${AGENT_DOCS_MESSAGE}`));
 	if (!README.test(base)) return Option.none();
-	if (yield* isPublished(root, files.dirname(name))) return Option.none();
+	if (HashSet.has(published, files.dirname(file))) return Option.none();
 	return Option.some(problemFor(file, `${base} ${README_MESSAGE}`));
 });
 /** @internal */
 const checkNestedDocs = Effect.fn("checkNestedDocs")(function* checkNestedDocs(root) {
 	const names = yield* (yield* RepositoryFiles).listedFiles(root);
 	const nested = pipe(names, Array.filter(isNested));
-	const found = yield* Effect.forEach(nested, (name) => problemIn(root, name), { concurrency: READ_CONCURRENCY$1 });
+	const workspaces = yield* publishedWorkspaces(root);
+	const published = pipe(workspaces, Array.map((workspace) => workspace.directory), HashSet.fromIterable);
+	const found = yield* Effect.forEach(nested, (name) => problemIn(root, published, name), { concurrency: READ_CONCURRENCY$1 });
 	return Array.getSomes(found);
 });
 // src/override-findings.ts
@@ -1251,7 +1667,8 @@ const checkAll = Effect.fn("checkAll")(function* checkAll(root) {
 		checkOverrides(root),
 		checkHiddenUnicode(root),
 		checkPython(root),
-		checkNestedDocs(root)
+		checkNestedDocs(root),
+		checkPublishedPackages(root)
 	], { concurrency: "unbounded" });
 	return Array.flatten(found);
 });
@@ -1271,7 +1688,7 @@ const reportFailure = (cause) => Effect.gen(function* report() {
 });
 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 services = Layer.mergeAll(nodeRepositoryFiles, tracing).pipe(Layer.provideMerge(nodeServicesLayer));
 	const main = Layer.build(services).pipe(Effect.flatMap((context) => Effect.provideContext(program.pipe(Effect.tapCause(reportFailure)), context)), Effect.scoped);
 	runMain(main, { disableErrorReporting: true });
 };