@stll/oxlint-config 0.12.2 → 0.15.0

package/dist/publish-contract-cli.cjs

@@ -0,0 +1,983 @@
+#!/usr/bin/env node
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("./rolldown-runtime.cjs");
+const require_toolchain_inputs = require("./toolchain-inputs.cjs");
+const require_toolchain_schema = require("./toolchain-schema.cjs");
+const require_publish_contract = require("./publish-contract.cjs");
+const require_publish_build_target_vite_dts_helper = require("./publish-build-target-vite-dts-helper2.cjs");
+let node_fs = require("node:fs");
+let node_child_process = require("node:child_process");
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let node_module = require("node:module");
+let node_os = require("node:os");
+let node_url = require("node:url");
+let acorn = require("acorn");
+let esbuild = require("esbuild");
+//#region src/publish-build-target-nuxt.ts
+const supportedVersions = {
+	"@nuxt/module-builder": "1.0.3",
+	unbuild: "3.6.1",
+	mkdist: "2.4.1"
+};
+const record$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Only the reviewed builder and branded target hook may introduce executable build behavior. */
+const assertNuxtOutputOptions = (options) => {
+	const visit = (value) => {
+		if (typeof value === "function") throw new Error("Unreviewed Nuxt output transform requires a supported target resolver");
+		if (Array.isArray(value)) {
+			for (const item of value) visit(item);
+			return;
+		}
+		if (typeof value !== "object" || value === null) return;
+		if (value instanceof RegExp) return;
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype !== Object.prototype && prototype !== null) throw new Error("Unsupported Nuxt output option prototype");
+		for (const key of Reflect.ownKeys(value)) {
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			if (typeof key !== "string" || !descriptor || !("value" in descriptor)) throw new Error("Unsupported Nuxt output option property");
+			const entry = descriptor.value;
+			if (key === "plugins" && entry !== void 0 && (!Array.isArray(entry) || entry.length > 0)) throw new Error("Unreviewed Nuxt output plugins require a supported target resolver");
+			visit(entry);
+		}
+	};
+	visit(options);
+};
+/** Read actual normalized entry targets, including mkdist's separate transform. */
+const resolvedNuxtTarget = (options) => {
+	assertNuxtOutputOptions(options);
+	if (!record$2(options) || !Array.isArray(options["entries"]) || options["entries"].length === 0) throw new Error("Nuxt must resolve at least one JavaScript entry");
+	const emitted = /* @__PURE__ */ new Set();
+	for (const entry of options["entries"]) {
+		if (!record$2(entry)) throw new Error("Invalid resolved Nuxt entry");
+		let transform;
+		switch (entry["builder"]) {
+			case "rollup":
+				if (!record$2(options["rollup"])) throw new Error("Invalid Nuxt module options");
+				transform = options["rollup"]["esbuild"];
+				break;
+			case "mkdist":
+				transform = entry["esbuild"];
+				break;
+			default: throw new Error("Unsupported Nuxt JavaScript entry builder");
+		}
+		if (transform !== void 0 && !record$2(transform)) throw new Error("Invalid Nuxt JavaScript transform options");
+		const target = record$2(transform) ? transform["target"] : void 0;
+		if (target === void 0) {
+			emitted.add("esnext");
+			continue;
+		}
+		const targets = typeof target === "string" ? [target] : target;
+		if (!Array.isArray(targets) || targets.length === 0) throw new Error("Unsupported resolved Nuxt JavaScript target");
+		for (const item of targets) {
+			if (typeof item !== "string" || item.length === 0) throw new Error("Unsupported resolved Nuxt JavaScript target");
+			emitted.add(item);
+		}
+	}
+	return {
+		type: "javascript",
+		targets: [...emitted].sort()
+	};
+};
+const captureProgram = String.raw`
+import { register } from 'node:module';
+const payload = JSON.parse(process.argv[1]);
+register(payload.loader, import.meta.url);
+const jitiModule = await import(payload.jiti);
+const createJiti = jitiModule.createJiti || jitiModule.default;
+const jiti = createJiti(payload.directory);
+const config = await jiti.import('./build.config', {try: true, default: true}) || {};
+const record = value => typeof value === 'object' && value !== null && !Array.isArray(value);
+if (!record(config) || Object.keys(config).some(key => key !== 'hooks')) throw new Error('Nuxt build configuration only supports the declared target hook');
+globalThis.__stllNuxtTargetHelper = undefined;
+globalThis.__stllNuxtTargetData = undefined;
+if (config.hooks !== undefined) {
+  if (!record(config.hooks) || Object.keys(config.hooks).length !== 1 || !('build:before' in config.hooks)) throw new Error('Nuxt build configuration only supports the declared target hook');
+  if (!payload.helper) throw new Error('Nuxt target helper must be installed at the same tooling version');
+  const helper = await jiti.import(payload.helper, {default: false});
+  const targets = helper.nuxtModuleTargetTargets(config.hooks['build:before']);
+  if (!targets) throw new Error('Nuxt build configuration requires immutable nuxtModuleTarget data');
+  config.hooks['build:before'] = helper.nuxtModuleTarget(targets);
+  globalThis.__stllNuxtTargetHelper = helper;
+  globalThis.__stllNuxtTargetData = targets;
+}
+globalThis.__stllNuxtAbort = new Error('Nuxt target captured');
+globalThis.__stllNuxtCapture = undefined;
+const tool = await import(payload.tool);
+try {
+  await tool.build.run({args: {cwd: payload.directory, rootDir: '.', outDir: 'dist', sourcemap: false, stub: false}});
+  throw new Error('Nuxt build did not reach the configuration boundary');
+} catch (error) {
+  if (error !== globalThis.__stllNuxtAbort) throw error;
+}
+console.log('__STLL_NUXT_TARGET__' + JSON.stringify(globalThis.__stllNuxtCapture));
+`;
+const captureShim = (unbuild) => `
+import {build as actualBuild} from ${JSON.stringify(unbuild)};
+export const build = (root, stub, input) => {
+  const expectedHooks = {...input.hooks};
+  const helper = globalThis.__stllNuxtTargetHelper;
+  if (helper) expectedHooks['build:before'] = helper.nuxtModuleTarget(globalThis.__stllNuxtTargetData);
+  const prepare = context => {
+      const helper = globalThis.__stllNuxtTargetHelper;
+      const loadedHooks = context.options.hooks;
+      if (!loadedHooks || typeof loadedHooks !== 'object' || Array.isArray(loadedHooks)) throw new Error('Nuxt target configuration changed during loading');
+      const expectedKeys = Reflect.ownKeys(expectedHooks);
+      const loadedKeys = Reflect.ownKeys(loadedHooks);
+      if (loadedKeys.length !== expectedKeys.length || loadedKeys.some(key => !expectedKeys.includes(key))) throw new Error('Nuxt target configuration changed during loading');
+      for (const key of loadedKeys) {
+        const descriptor = Object.getOwnPropertyDescriptor(loadedHooks, key);
+        if (!descriptor || !('value' in descriptor)) throw new Error('Nuxt target configuration changed during loading');
+        if (key === 'build:before' && helper) continue;
+        if (descriptor.value !== expectedHooks[key]) throw new Error('Nuxt target configuration changed during loading');
+      }
+      const declared = loadedHooks['build:before'];
+      if (helper) {
+        const targets = helper.nuxtModuleTargetTargets(declared);
+        if (!targets || JSON.stringify(targets) !== JSON.stringify(globalThis.__stllNuxtTargetData)) throw new Error('Nuxt target configuration changed during loading');
+        if (typeof context.hooks.removeHook !== 'function') throw new Error('Unsupported Nuxt hook registration interface');
+        // unbuild registers config hooks before build:prepare; remove that exact callback.
+        context.hooks.removeHook('build:before', declared);
+        const canonical = helper.nuxtModuleTarget(targets);
+        context.options.hooks['build:before'] = canonical;
+        context.hooks.hook('build:before', canonical);
+      }
+      // unbuild 3.6.1 normalizes entries before build:before, then cleans output.
+      // Append after all registered config hooks so the target helper runs first.
+      context.hooks.hook('build:before', final => {
+        // The reviewed constructor owns its later hooks; user config accepts only nuxtModuleTarget.
+        // Validate executable output options before projecting away functions for the capture.
+        (${assertNuxtOutputOptions.toString()})({entries: final.options.entries, rollup: final.options.rollup});
+        globalThis.__stllNuxtCapture = {
+          entries: final.options.entries.map(entry => ({builder: entry.builder, esbuild: entry.esbuild})),
+          rollup: {esbuild: final.options.rollup.esbuild}
+        };
+        throw globalThis.__stllNuxtAbort;
+      });
+  };
+  expectedHooks['build:prepare'] = prepare;
+  return actualBuild(root, stub, {...input, hooks: {...input.hooks, 'build:prepare': prepare}});
+};
+`;
+const resolveNuxtPublishTarget = (directory) => {
+	const canonicalDirectory = (0, node_fs.realpathSync)(directory);
+	const require = (0, node_module.createRequire)(node_path.default.join(canonicalDirectory, "package.json"));
+	const manifest = JSON.parse((0, node_fs.readFileSync)(node_path.default.join(canonicalDirectory, "package.json"), "utf8"));
+	if (!record$2(manifest) || manifest["build"] !== void 0 || manifest["unbuild"] !== void 0 || record$2(manifest["publishConfig"]) && (manifest["publishConfig"]["build"] !== void 0 || manifest["publishConfig"]["unbuild"] !== void 0)) throw new Error("Nuxt manifest build overrides require a supported target resolver");
+	const configs = [
+		"ts",
+		"mts",
+		"cts",
+		"js",
+		"mjs",
+		"cjs",
+		"json"
+	].filter((extension) => (0, node_fs.existsSync)(node_path.default.join(canonicalDirectory, `build.config.${extension}`)));
+	if (configs.length > 1) throw new Error("Nuxt supports exactly one build configuration");
+	const tool = (0, node_fs.realpathSync)(require.resolve("@nuxt/module-builder"));
+	const unbuild = (0, node_fs.realpathSync)((0, node_module.createRequire)(tool).resolve("unbuild"));
+	const unbuildRequire = (0, node_module.createRequire)(unbuild);
+	for (const [name, version] of Object.entries(supportedVersions)) {
+		let entry;
+		switch (name) {
+			case "@nuxt/module-builder":
+				entry = tool;
+				break;
+			case "unbuild":
+				entry = unbuild;
+				break;
+			case "mkdist":
+				entry = (0, node_fs.realpathSync)(unbuildRequire.resolve("mkdist"));
+				break;
+			default: throw new Error(`Unsupported Nuxt build tool ${name}`);
+		}
+		const metadata = JSON.parse((0, node_fs.readFileSync)(node_path.default.resolve(node_path.default.dirname(entry), "../package.json"), "utf8"));
+		if (!record$2(metadata) || metadata["version"] !== version) throw new Error(`Publish target resolver supports ${name} ${version}; review the adapter before changing build tools`);
+	}
+	let helper;
+	if (configs.length > 0) {
+		const helperEntry = (0, node_fs.realpathSync)(require.resolve("@stll/oxlint-config/build-target"));
+		const metadata = JSON.parse((0, node_fs.readFileSync)(node_path.default.resolve(node_path.default.dirname(helperEntry), "../package.json"), "utf8"));
+		const ownMetadata = JSON.parse((0, node_fs.readFileSync)(new URL("../package.json", require("url").pathToFileURL(__filename).href), "utf8"));
+		if (!record$2(metadata) || !record$2(ownMetadata) || metadata["version"] !== ownMetadata["version"]) throw new Error("Nuxt target helper must use the same tooling version as the resolver");
+		helper = (0, node_url.pathToFileURL)(helperEntry).href;
+	}
+	const shim = `data:text/javascript,${encodeURIComponent(captureShim((0, node_url.pathToFileURL)(unbuild).href))}`;
+	const loader = `
+import {realpathSync} from 'node:fs';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+export const resolve=(specifier,context,next)=>{
+  if(specifier!=='unbuild')return next(specifier,context);
+  if(!context.parentURL||!context.parentURL.startsWith('file:')||path.dirname(realpathSync(fileURLToPath(context.parentURL)))!==${JSON.stringify(node_path.default.dirname(tool))})throw new Error('Unexpected Nuxt unbuild import parent');
+  return {url:${JSON.stringify(shim)},shortCircuit:true};
+};`;
+	const captures = (0, node_child_process.execFileSync)(process.versions.bun ? "node" : process.execPath, [
+		"--input-type=module",
+		"-e",
+		captureProgram,
+		JSON.stringify({
+			directory: canonicalDirectory,
+			tool: (0, node_url.pathToFileURL)(tool).href,
+			unbuild: (0, node_url.pathToFileURL)(unbuild).href,
+			jiti: (0, node_url.pathToFileURL)((0, node_fs.realpathSync)(unbuildRequire.resolve("jiti"))).href,
+			helper,
+			loader: `data:text/javascript,${encodeURIComponent(loader)}`
+		})
+	], {
+		cwd: canonicalDirectory,
+		encoding: "utf8",
+		timeout: 3e4,
+		maxBuffer: 1024 * 1024,
+		env: {
+			...process.env,
+			JITI_FS_CACHE: "0",
+			JITI_MODULE_CACHE: "1"
+		}
+	}).split("\n").filter((line) => line.startsWith("__STLL_NUXT_TARGET__"));
+	const capture = captures.at(0);
+	if (captures.length !== 1 || capture === void 0) throw new Error("Nuxt did not return exactly one resolved build configuration");
+	return resolvedNuxtTarget(JSON.parse(capture.slice(20)));
+};
+//#endregion
+//#region src/publish-build-target-vite.ts
+const supportedViteVersion = "8.1.5";
+const declarationHelperImport = "@stll/oxlint-config/declaration-only-dts";
+const record$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const walkAst = ({ value, visit, parent }) => {
+	if (Array.isArray(value)) {
+		for (const entry of value) walkAst({
+			value: entry,
+			visit,
+			...parent === void 0 ? {} : { parent }
+		});
+		return;
+	}
+	if (!record$1(value)) return;
+	visit(value, parent);
+	for (const entry of Object.values(value)) if (typeof entry === "object" && entry !== null) walkAst({
+		value: entry,
+		visit,
+		parent: value
+	});
+};
+const astName = (value) => record$1(value) && value["type"] === "Identifier" ? value["name"] : void 0;
+const astLiteral = (value) => {
+	if (!record$1(value)) throw new Error("Declaration helper options must be literal");
+	if (value["type"] === "Literal" && (typeof value["value"] === "string" || typeof value["value"] === "boolean")) return value["value"];
+	if (value["type"] === "ArrayExpression" && Array.isArray(value["elements"])) return value["elements"].map(astLiteral);
+	if (value["type"] === "ObjectExpression" && Array.isArray(value["properties"])) {
+		const entries = [];
+		for (const property of value["properties"]) {
+			if (!record$1(property) || property["type"] !== "Property" || property["kind"] !== "init" || property["computed"] === true || property["method"] === true || property["shorthand"] === true) throw new Error("Declaration helper options must be plain literal properties");
+			const key = astName(property["key"]) ?? (record$1(property["key"]) ? property["key"]["value"] : void 0);
+			if (typeof key !== "string" || entries.some(([previous]) => previous === key)) throw new Error("Invalid declaration helper option key");
+			entries.push([key, astLiteral(property["value"])]);
+		}
+		return Object.fromEntries(entries);
+	}
+	throw new Error("Declaration helper options must be literal");
+};
+/** Prove the helper owns the directly declared plugin; closure brands alone are insufficient. */
+const reviewedDtsConfiguration = ({ source, directory, loader }) => {
+	const ast = (0, acorn.parse)((0, esbuild.transformSync)(source, {
+		loader,
+		format: "esm",
+		target: "esnext"
+	}).code, {
+		ecmaVersion: "latest",
+		sourceType: "module"
+	});
+	if (!record$1(ast) || !Array.isArray(ast["body"])) throw new Error("Invalid Vite configuration AST");
+	const bindings = /* @__PURE__ */ new Set();
+	const defineConfigBindings = /* @__PURE__ */ new Set();
+	const initializers = /* @__PURE__ */ new Map();
+	let exported;
+	for (const statement of ast["body"]) {
+		if (!record$1(statement)) continue;
+		if (statement["type"] === "ImportDeclaration" && record$1(statement["source"])) {
+			const imported = statement["source"]["value"];
+			if (typeof imported === "string" && /^(?:vite-plugin-dts|unplugin-dts)(?:\/|$)/.test(imported)) throw new Error("Raw declaration emitters cannot accompany the reviewed helper");
+			if (Array.isArray(statement["specifiers"])) for (const specifier of statement["specifiers"]) {
+				if (!record$1(specifier)) continue;
+				const local = astName(specifier["local"]);
+				const name = astName(specifier["imported"]);
+				if (imported === declarationHelperImport) {
+					if (specifier["type"] !== "ImportSpecifier" || name !== "declarationOnlyDts" || typeof local !== "string") throw new Error("Use the named declarationOnlyDts helper import");
+					bindings.add(local);
+				}
+				if (imported === "vite" && name === "defineConfig" && typeof local === "string") defineConfigBindings.add(local);
+			}
+		}
+		if (statement["type"] === "VariableDeclaration" && Array.isArray(statement["declarations"])) {
+			for (const declaration of statement["declarations"]) if (record$1(declaration)) initializers.set(astName(declaration["id"]), declaration["init"]);
+		}
+		if (statement["type"] === "ExportDefaultDeclaration") exported = statement["declaration"];
+		if (statement["type"] === "ExportNamedDeclaration" && Array.isArray(statement["specifiers"])) {
+			for (const specifier of statement["specifiers"]) if (record$1(specifier) && astName(specifier["exported"]) === "default") exported = specifier["local"];
+		}
+	}
+	if (bindings.size !== 1) throw new Error("Vite declaration plugins require one statically imported helper");
+	if (record$1(exported) && exported["type"] === "Identifier") exported = initializers.get(astName(exported));
+	if (record$1(exported) && exported["type"] === "CallExpression" && defineConfigBindings.has(String(astName(exported["callee"]))) && Array.isArray(exported["arguments"]) && exported["arguments"].length === 1) exported = exported["arguments"].at(0);
+	if (!record$1(exported) || exported["type"] !== "ObjectExpression" || !Array.isArray(exported["properties"])) throw new Error("Declaration helper requires a directly exported static Vite configuration");
+	const pluginProperties = exported["properties"].filter((property) => record$1(property) && (astName(property["key"]) === "plugins" || record$1(property["key"]) && property["key"]["value"] === "plugins"));
+	const property = pluginProperties.at(0);
+	if (pluginProperties.length !== 1 || !record$1(property) || property["computed"] === true || property["kind"] !== "init" || !record$1(property["value"]) || property["value"]["type"] !== "ArrayExpression" || !Array.isArray(property["value"]["elements"])) throw new Error("Declaration helper requires a literal plugins array");
+	const calls = property["value"]["elements"].map((element) => record$1(element) && element["type"] === "AwaitExpression" ? element["argument"] : element).filter((element) => record$1(element) && element["type"] === "CallExpression" && bindings.has(String(astName(element["callee"]))));
+	const call = calls.at(0);
+	if (calls.length !== 1 || !record$1(call) || !Array.isArray(call["arguments"]) || call["arguments"].length !== 1) throw new Error("Declare exactly one direct declaration helper call");
+	walkAst({
+		value: ast,
+		visit: (node, parent) => {
+			if (node["type"] === "ImportDeclaration") return;
+			const name = astName(node);
+			if (typeof name !== "string" || !bindings.has(name)) return;
+			if (parent?.["type"] === "ImportSpecifier") return;
+			if (parent !== call || call["callee"] !== node) throw new Error("Declaration helper binding cannot be aliased or invoked indirectly");
+		}
+	});
+	const argument = call["arguments"].at(0);
+	if (!record$1(argument) || argument["type"] !== "ObjectExpression" || !Array.isArray(argument["properties"])) throw new Error("Declaration helper options must be a literal object");
+	const directoryProperties = argument["properties"].filter((entry) => record$1(entry) && astName(entry["key"]) === "directory");
+	const directoryProperty = directoryProperties.at(0);
+	if (directoryProperties.length !== 1 || !record$1(directoryProperty) || directoryProperty["computed"] === true || directoryProperty["kind"] !== "init") throw new Error("Declaration helper requires its package directory");
+	const value = directoryProperty["value"];
+	const meta = record$1(value) ? value["object"] : void 0;
+	const importDirectory = record$1(value) && value["type"] === "MemberExpression" && value["computed"] === false && astName(value["property"]) === "dirname" && record$1(meta) && meta["type"] === "MetaProperty" && astName(meta["meta"]) === "import" && astName(meta["property"]) === "meta";
+	const exactDirectory = record$1(value) && value["type"] === "Literal" && value["value"] === directory;
+	if (!importDirectory && !exactDirectory) throw new Error("Declaration helper directory must be import.meta.dirname or the exact package directory");
+	return require_publish_build_target_vite_dts_helper.reviewedViteDtsOptions(astLiteral({
+		...argument,
+		properties: argument["properties"].filter((entry) => entry !== directoryProperty)
+	}));
+};
+const ownEntries = (value) => Reflect.ownKeys(value).map((key) => {
+	const descriptor = Object.getOwnPropertyDescriptor(value, key);
+	if (typeof key !== "string" || !descriptor || !("value" in descriptor)) throw new Error("Unsupported Vite hook property");
+	return [key, descriptor.value];
+});
+const metadataSource = (value) => {
+	if (value instanceof RegExp) return JSON.stringify([
+		"regexp",
+		value.source,
+		value.flags
+	]);
+	if (Array.isArray(value)) return JSON.stringify(["array", value.map(metadataSource)]);
+	if (record$1(value)) {
+		if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new Error("Unsupported Vite hook metadata");
+		return JSON.stringify(["object", ownEntries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, metadataSource(item)])]);
+	}
+	if (value === void 0) return "undefined";
+	if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) return JSON.stringify(value);
+	throw new Error("Unsupported Vite hook metadata");
+};
+const hookSource = (value) => {
+	if (typeof value === "function") return JSON.stringify(["function", Function.prototype.toString.call(value)]);
+	if (!record$1(value)) throw new Error("Unsupported Vite build hook");
+	if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new Error("Unsupported Vite hook metadata");
+	const entries = ownEntries(value);
+	const handler = entries.find(([key]) => key === "handler")?.[1];
+	if (typeof handler !== "function") throw new Error("Unsupported Vite build hook");
+	const metadata = entries.filter(([key]) => key !== "handler");
+	if (metadata.some(([key]) => ![
+		"order",
+		"sequential",
+		"filter"
+	].includes(key))) throw new Error("Unsupported Vite hook metadata");
+	return JSON.stringify([
+		"object",
+		Function.prototype.toString.call(handler),
+		metadataSource(Object.fromEntries(metadata))
+	]);
+};
+const pluginEntries = (plugin) => {
+	const entries = /* @__PURE__ */ new Map();
+	let current = plugin;
+	while (current !== Object.prototype) {
+		for (const [key, value] of ownEntries(current)) {
+			if (current !== plugin && key === "constructor") continue;
+			if (!entries.has(key)) entries.set(key, value);
+		}
+		const prototype = Object.getPrototypeOf(current);
+		if (prototype === null) break;
+		if (!record$1(prototype)) throw new Error("Unsupported Vite plugin prototype");
+		current = prototype;
+	}
+	return entries;
+};
+const plugins = (config) => {
+	if (!record$1(config) || !record$1(config["build"]) || !record$1(config["environments"])) throw new Error("Invalid Vite plugin configuration");
+	const environment = config["environments"][config["build"]["ssr"] === true || typeof config["build"]["ssr"] === "string" && config["build"]["ssr"] !== "" ? "ssr" : "client"];
+	if (!record$1(environment) || !Array.isArray(environment["plugins"]) || !Array.isArray(config["plugins"])) throw new Error("Missing resolved Vite environment plugins");
+	const options = config["build"]["rolldownOptions"];
+	const extra = record$1(options) ? options["plugins"] : void 0;
+	if (extra !== void 0 && !Array.isArray(extra)) throw new Error("Dynamic Vite rolldown plugins require a supported target resolver");
+	return [
+		...config["plugins"],
+		...environment["plugins"],
+		...extra ?? []
+	].flat(Infinity);
+};
+/** Vue hook closures may only capture the reviewed factory's default options. */
+const assertReviewedVueOptions = ({ plugin, reviewed }) => {
+	const fail = () => /* @__PURE__ */ new Error("Custom Vue plugin options require a supported target resolver");
+	if (!record$1(plugin) || !record$1(reviewed) || !record$1(plugin["api"]) || !record$1(reviewed["api"])) throw fail();
+	const api = plugin["api"];
+	const defaults = reviewed["api"];
+	const options = api["options"];
+	const defaultOptions = defaults["options"];
+	if (!record$1(options) || !record$1(defaultOptions)) throw fail();
+	if (Object.getPrototypeOf(options) !== Object.prototype && Object.getPrototypeOf(options) !== null) throw fail();
+	if (metadataSource(api["include"]) !== metadataSource(defaults["include"]) || api["exclude"] !== void 0) throw fail();
+	const lifecycleFields = /* @__PURE__ */ new Set([
+		"isProduction",
+		"sourceMap",
+		"cssDevSourcemap",
+		"devToolsEnabled"
+	]);
+	for (const [key, value] of ownEntries(options)) {
+		if (key === "root") {
+			if (typeof value !== "string") throw fail();
+			continue;
+		}
+		if (lifecycleFields.has(key)) {
+			if (typeof value !== "boolean") throw fail();
+			continue;
+		}
+		if (key === "compiler") {
+			if (value !== null && value !== void 0) throw fail();
+			continue;
+		}
+		if (!Object.hasOwn(defaultOptions, key) || metadataSource(value) !== metadataSource(defaultOptions[key])) throw fail();
+	}
+	for (const [key] of ownEntries(defaultOptions)) if (!Object.hasOwn(options, key) && key !== "compiler") throw fail();
+};
+const vitePluginMetadata = /* @__PURE__ */ new Set([
+	"enforce",
+	"_options",
+	"perEnvironmentStartEndDuringDev",
+	"perEnvironmentWatchChangeDuringDev"
+]);
+const nativeCallbackFields = /* @__PURE__ */ new Map([
+	["builtin:vite-resolve", "resolveSubpathImports"],
+	["builtin:vite-dynamic-import-vars", "resolver"],
+	["builtin:vite-reporter", "logInfo"]
+]);
+const nativeOptionsSource = (name, value) => {
+	if (!record$1(value)) return metadataSource(value);
+	if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new Error("Unsupported Vite native options");
+	return JSON.stringify(ownEntries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => {
+		if (key === nativeCallbackFields.get(name) && typeof item === "function") return [
+			key,
+			"reviewed-callback",
+			Function.prototype.toString.call(item)
+		];
+		return [
+			key,
+			"metadata",
+			metadataSource(item)
+		];
+	}));
+};
+const pluginSources = (plugin) => {
+	const entries = pluginEntries(plugin);
+	for (const key of [...vitePluginMetadata, "apply"]) if (!entries.has(key)) entries.set(key, void 0);
+	const sources = /* @__PURE__ */ new Map();
+	for (const [key, value] of entries) {
+		if (key === "name" || key === "api") continue;
+		if (key === "_options") {
+			const name = entries.get("name");
+			if (typeof name !== "string") throw new Error("Invalid Vite plugin name");
+			sources.set(key, `native:${nativeOptionsSource(name, value)}`);
+			continue;
+		}
+		if (vitePluginMetadata.has(key) || key === "apply" && typeof value !== "function") sources.set(key, `metadata:${metadataSource(value)}`);
+		else if (value === void 0) sources.set(key, "absent-hook");
+		else sources.set(key, `hook:${hookSource(value)}`);
+	}
+	return sources;
+};
+/** Reviewed tool versions own the plugin name, hook name and implementation together. */
+const assertReviewedVitePlugins = ({ resolved, reviewed }) => {
+	const identities = /* @__PURE__ */ new Map();
+	for (const plugin of reviewed) {
+		if (!record$1(plugin) || typeof plugin["name"] !== "string") throw new Error("Invalid reviewed Vite plugin");
+		const name = plugin["name"];
+		const hooks = identities.get(name) ?? /* @__PURE__ */ new Map();
+		identities.set(name, hooks);
+		for (const [key, source] of pluginSources(plugin)) {
+			const sources = hooks.get(key) ?? /* @__PURE__ */ new Set();
+			sources.add(source);
+			hooks.set(key, sources);
+		}
+	}
+	for (const plugin of resolved) {
+		if (plugin === void 0 || plugin === null || plugin === false) continue;
+		if (!record$1(plugin) || typeof plugin["name"] !== "string") throw new Error("Dynamic Vite plugins require a supported target resolver");
+		const name = plugin["name"];
+		const hooks = identities.get(name);
+		if (hooks === void 0) throw new Error(`Unreviewed Vite plugin ${name} requires a supported target resolver`);
+		for (const [key, source] of pluginSources(plugin)) if (!hooks.get(key)?.has(source)) throw new Error(`Unreviewed Vite hook ${name}:${key} requires a supported target resolver`);
+	}
+	const pipelineIdentity = (plugin) => {
+		if (!record$1(plugin) || typeof plugin["name"] !== "string") throw new Error("Invalid reviewed Vite pipeline entry");
+		return JSON.stringify([plugin["name"], [...pluginSources(plugin)].sort(([a], [b]) => a.localeCompare(b))]);
+	};
+	const actualPipeline = resolved.filter((plugin) => plugin !== void 0 && plugin !== null && plugin !== false);
+	if (actualPipeline.length !== reviewed.length || reviewed.some((plugin, index) => pipelineIdentity(plugin) !== pipelineIdentity(actualPipeline[index]))) throw new Error("Vite plugin pipeline must match the complete reviewed order");
+};
+/** Vite 8 spreads transform overrides after its resolved build target. */
+const resolvedViteTarget = (config) => {
+	if (!record$1(config) || !record$1(config["build"])) throw new Error("Invalid resolved Vite build configuration");
+	if (config["builder"] !== void 0) throw new Error("Custom Vite builders require a supported target resolver");
+	const build = config["build"];
+	const options = build["rolldownOptions"];
+	if (options !== void 0 && !record$1(options)) throw new Error("Vite rolldownOptions must be an object");
+	const output = record$1(options) ? options["output"] : void 0;
+	if (output !== void 0) {
+		const outputs = Array.isArray(output) ? output : [output];
+		for (const entry of outputs) {
+			if (!record$1(entry)) throw new Error("Unsupported Vite output options");
+			for (const key of [
+				"banner",
+				"footer",
+				"intro",
+				"outro"
+			]) if (entry[key] !== void 0 && entry[key] !== "") throw new Error("Vite output addons require a supported target resolver");
+			const outputPlugins = entry["plugins"];
+			if (outputPlugins !== void 0 && (!Array.isArray(outputPlugins) || outputPlugins.length > 0)) throw new Error("Vite output plugins require a supported target resolver");
+		}
+	}
+	const transform = record$1(options) ? options["transform"] : void 0;
+	if (transform !== void 0 && !record$1(transform)) throw new Error("Vite transform overrides must be an object");
+	let target = build["target"] === false ? void 0 : build["target"];
+	if (record$1(transform) && "target" in transform) target = transform["target"];
+	if (target === void 0) return {
+		type: "javascript",
+		targets: ["esnext"]
+	};
+	const targets = typeof target === "string" ? [target] : target;
+	if (!Array.isArray(targets) || targets.length === 0) throw new Error("Unsupported resolved Vite JavaScript target");
+	const emitted = /* @__PURE__ */ new Set();
+	for (const item of targets) {
+		if (typeof item !== "string" || item.length === 0) throw new Error("Unsupported resolved Vite JavaScript target");
+		emitted.add(item);
+	}
+	return {
+		type: "javascript",
+		targets: [...emitted].sort()
+	};
+};
+/** Only static build settings needed by the installed tool's canonical profile cross this boundary. */
+const reviewedViteBuild = (build) => {
+	if (!record$1(build)) throw new Error("Invalid Vite build configuration");
+	const properties = new Map(ownEntries(build));
+	const result = {};
+	for (const key of [
+		"target",
+		"sourcemap",
+		"minify",
+		"ssr",
+		"cssCodeSplit",
+		"assetsInlineLimit",
+		"assetsDir",
+		"reportCompressedSize",
+		"chunkSizeWarningLimit",
+		"modulePreload"
+	]) {
+		const value = properties.get(key);
+		metadataSource(value);
+		result[key] = value;
+	}
+	const library = properties.get("lib");
+	if (record$1(library)) {
+		if (Object.getPrototypeOf(library) !== Object.prototype && Object.getPrototypeOf(library) !== null) throw new Error("Unsupported Vite library configuration");
+		const libraryProperties = new Map(ownEntries(library));
+		const fields = {};
+		for (const key of [
+			"entry",
+			"formats",
+			"name"
+		]) {
+			const value = libraryProperties.get(key);
+			metadataSource(value);
+			fields[key] = value;
+		}
+		result["lib"] = fields;
+	} else if (library === void 0 || library === false) result["lib"] = library;
+	else throw new Error("Unsupported Vite library configuration");
+	return result;
+};
+const resolveVitePublishTarget = async (directory) => {
+	const canonicalDirectory = (0, node_fs.realpathSync)(directory);
+	const require = (0, node_module.createRequire)(node_path.default.join(canonicalDirectory, "package.json"));
+	const metadata = JSON.parse((0, node_fs.readFileSync)(require.resolve("vite/package.json"), "utf8"));
+	if (!record$1(metadata) || metadata["version"] !== supportedViteVersion) throw new Error(`Publish target resolver supports Vite ${supportedViteVersion}; review the adapter before changing build tools`);
+	const tool = await import((0, node_url.pathToFileURL)((0, node_fs.realpathSync)(require.resolve("vite"))).href);
+	if (!record$1(tool) || typeof tool["resolveConfig"] !== "function") throw new Error("Installed Vite does not expose its configuration resolver");
+	const patchConfig = (resolved) => {
+		if (!record$1(resolved) || !record$1(resolved["build"]) || !record$1(resolved["environments"])) throw new Error("Invalid Vite environment configuration");
+		if (resolved["builder"] !== void 0) throw new Error("Custom Vite builders require a supported target resolver");
+		const environment = resolved["environments"][resolved["build"]["ssr"] === true || typeof resolved["build"]["ssr"] === "string" && resolved["build"]["ssr"] !== "" ? "ssr" : "client"];
+		if (!record$1(environment) || !record$1(environment["build"])) throw new Error("Missing resolved Vite build environment");
+		resolved["build"] = { ...environment["build"] };
+	};
+	const config = await tool["resolveConfig"]({ root: canonicalDirectory }, "build", "production", "production", false, patchConfig);
+	if (!record$1(config) || !record$1(config["build"])) throw new Error("Invalid Vite build configuration");
+	const resolvedPlugins = plugins(config);
+	const canonicalVuePlugins = [];
+	if (resolvedPlugins.some((plugin) => record$1(plugin) && plugin["name"] === "vite:vue")) {
+		const vueMetadata = JSON.parse((0, node_fs.readFileSync)(require.resolve("@vitejs/plugin-vue/package.json"), "utf8"));
+		if (!record$1(vueMetadata) || vueMetadata["version"] !== "6.0.8") throw new Error("Publish target resolver supports @vitejs/plugin-vue 6.0.8; review the adapter before changing build tools");
+		const vue = await import((0, node_url.pathToFileURL)((0, node_fs.realpathSync)(require.resolve("@vitejs/plugin-vue"))).href);
+		if (!record$1(vue) || typeof vue["default"] !== "function") throw new Error("Invalid installed Vue plugin factory");
+		const plugin = vue["default"]();
+		if (!record$1(plugin)) throw new Error("Invalid installed Vue plugin");
+		for (const resolved of resolvedPlugins) if (record$1(resolved) && resolved["name"] === "vite:vue") assertReviewedVueOptions({
+			plugin: resolved,
+			reviewed: plugin
+		});
+		canonicalVuePlugins.push(plugin);
+	}
+	if (resolvedPlugins.some((plugin) => record$1(plugin) && plugin["name"] === "stll:declaration-only-dts")) {
+		const configFile = config["configFile"];
+		if (typeof configFile !== "string" || node_path.default.dirname((0, node_fs.realpathSync)(configFile)) !== canonicalDirectory) throw new Error("Declaration helper requires a package-local Vite config file");
+		const options = reviewedDtsConfiguration({
+			source: (0, node_fs.readFileSync)(configFile, "utf8"),
+			directory: canonicalDirectory,
+			loader: /\.[cm]?ts$/.test(configFile) ? "ts" : "js"
+		});
+		canonicalVuePlugins.push(require_publish_build_target_vite_dts_helper.declarationOnlyDts({
+			directory: canonicalDirectory,
+			...options
+		}));
+	}
+	const canonicalBuild = reviewedViteBuild(config["build"]);
+	const canonical = await tool["resolveConfig"]({
+		root: canonicalDirectory,
+		configFile: false,
+		plugins: canonicalVuePlugins,
+		build: canonicalBuild
+	}, "build", "production", "production", false, patchConfig);
+	if (!record$1(canonical) || !record$1(canonical["build"]) || hookSource(config["build"]["createEnvironment"]) !== hookSource(canonical["build"]["createEnvironment"])) throw new Error("Custom Vite createEnvironment requires a supported target resolver");
+	const reviewedPlugins = plugins(canonical);
+	assertReviewedVitePlugins({
+		resolved: resolvedPlugins,
+		reviewed: reviewedPlugins
+	});
+	return resolvedViteTarget(config);
+};
+//#endregion
+//#region src/publish-build-target.ts
+const supportedTsdownVersion = "0.22.9";
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const targets = (value) => {
+	if (value === void 0) return ["esnext"];
+	if (typeof value === "string") {
+		const identifier = value.trim();
+		if (identifier === "" || identifier.includes(",")) throw new Error("Resolved JavaScript target identifiers must be nonempty and contain no commas");
+		return [identifier];
+	}
+	if (Array.isArray(value) && value.length > 0 && Array.from(value).every((item) => typeof item === "string")) return value.flatMap((item) => targets(item));
+	throw new Error("Build tool returned an unsupported resolved JavaScript target");
+};
+/** Only hooks completed by configuration resolution may run before target capture. */
+const assertTsdownBuildExtensions = (options) => {
+	const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+	const entries = (value) => {
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype !== Object.prototype && prototype !== null) throw new Error("Unreviewed build option prototype requires a supported target resolver");
+		return Reflect.ownKeys(value).map((key) => {
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			if (typeof key !== "string" || !descriptor || !("value" in descriptor)) throw new Error("Unreviewed build option property requires a supported target resolver");
+			return [key, descriptor.value];
+		});
+	};
+	const plugins = (value, phase) => {
+		if (value === void 0 || value === null || value === false) return;
+		if (Array.isArray(value)) {
+			for (const plugin of value) plugins(plugin, phase);
+			return;
+		}
+		if (!isRecord(value)) throw new Error("Dynamic plugins require a supported target resolver");
+		for (const [key, item] of entries(value)) {
+			if (item === void 0) continue;
+			if (key === "name" && typeof item === "string") continue;
+			if (phase === "configuration" && ["tsdownConfig", "tsdownConfigResolved"].includes(key) && typeof item === "function") continue;
+			throw new Error("Unreviewed plugin hooks require a supported target resolver");
+		}
+	};
+	const output = (value) => {
+		if (value === void 0) return;
+		if (!isRecord(value)) throw new Error("Dynamic output options require a supported target resolver");
+		for (const [key, item] of entries(value)) {
+			if (key === "plugins") plugins(item, "output");
+			if ([
+				"banner",
+				"footer",
+				"intro",
+				"outro"
+			].includes(key) && item !== void 0 && item !== "") throw new Error("Output addons require a supported target resolver");
+		}
+	};
+	if (!isRecord(options)) throw new Error("Invalid build configuration");
+	const properties = new Map(entries(options));
+	if (properties.get("hooks") !== void 0) throw new Error("Build hooks require a supported target resolver");
+	plugins(properties.get("plugins"), "configuration");
+	output(properties.get("outputOptions"));
+	for (const key of ["banner", "footer"]) {
+		const addon = properties.get(key);
+		if (addon !== void 0 && addon !== "") throw new Error("Output addons require a supported target resolver");
+	}
+	const input = properties.get("inputOptions");
+	if (input !== void 0) {
+		if (!isRecord(input)) throw new Error("Dynamic tsdown inputOptions require a supported target resolver");
+		plugins(new Map(entries(input)).get("plugins"), "output");
+	}
+};
+/** Extract the final target after supported format and low-level overrides. */
+const resolvedTsdownTarget = (configs) => {
+	if (!Array.isArray(configs) || configs.length === 0) throw new Error("tsdown must resolve at least one build configuration");
+	const emitted = /* @__PURE__ */ new Set();
+	let javascript = false;
+	for (const config of configs) {
+		if (!record(config)) throw new Error("Invalid resolved tsdown configuration");
+		assertTsdownBuildExtensions(config);
+		if (record(config["dts"]) && config["dts"]["emitDtsOnly"] === true) continue;
+		javascript = true;
+		const input = config["inputOptions"];
+		if (input !== void 0 && !record(input)) throw new Error("Dynamic tsdown inputOptions require a supported target resolver");
+		const transform = record(input) ? input["transform"] : void 0;
+		if (transform !== void 0 && !record(transform)) throw new Error("tsdown transform overrides must be an object");
+		const target = record(transform) && transform["target"] != null ? transform["target"] : config["target"];
+		for (const item of targets(target)) emitted.add(item);
+	}
+	return javascript ? {
+		type: "javascript",
+		targets: [...emitted].sort()
+	} : { type: "types-only" };
+};
+const exportPaths = (value) => {
+	if (typeof value === "string") return [value];
+	if (value === null || value === void 0) return [];
+	if (Array.isArray(value)) return value.flatMap((item) => exportPaths(item));
+	if (record(value)) return Object.values(value).flatMap(exportPaths);
+	throw new Error("Invalid package export declaration");
+};
+const publishBuildScript = "build";
+const publishBuildLifecycleScripts = [`pre${publishBuildScript}`, `post${publishBuildScript}`];
+const assertPublishBuildLifecycle = (manifest) => {
+	const scripts = manifest["scripts"];
+	if (!record(scripts)) return;
+	for (const script of publishBuildLifecycleScripts) if (Object.hasOwn(scripts, script)) throw new Error(`Publish target resolver does not support lifecycle script ${script}`);
+};
+/** JSON and declaration-only packages have no emitted JavaScript target. */
+const assetOnlyTarget = (manifest, packer) => {
+	if (!record(manifest)) throw new Error("Package manifest must be an object");
+	assertPublishBuildLifecycle(manifest);
+	if (record(manifest["scripts"]) && manifest["scripts"]["build"] !== void 0) return void 0;
+	const published = require_publish_contract.resolveManifestContract({
+		manifest,
+		packer,
+		target: { type: "types-only" }
+	});
+	const paths = [
+		"exports",
+		"main",
+		"module",
+		"types",
+		"typings",
+		"bin"
+	].flatMap((key) => exportPaths(published.entryPoints[key]));
+	if (paths.length === 0 || paths.some((item) => !/(?:\.json|\.d\.(?:ts|mts|cts))$/.test(item))) return void 0;
+	return { type: "types-only" };
+};
+/** Supported build commands have no shell composition or runtime relocation. */
+const supportedPublishBuildCommand = (build) => {
+	switch (build.replace(/[ \t]+/g, " ").replace(/^ | $/g, "")) {
+		case "tsdown": return "tsdown";
+		case "vite build": return "vite";
+		case "nuxt-module-build build": return "nuxt-module-build";
+	}
+	throw new Error("Publish target resolver requires an exact single invocation: tsdown, vite build, or nuxt-module-build build; shell composition, launchers, filters and CLI overrides are unsupported");
+};
+const resolvePublishBuildTarget = async (directory, packer) => {
+	const manifest = JSON.parse((0, node_fs.readFileSync)(node_path.default.join(directory, "package.json"), "utf8"));
+	const assets = assetOnlyTarget(manifest, packer);
+	if (assets !== void 0) return assets;
+	if (!record(manifest) || !record(manifest["scripts"]) || typeof manifest["scripts"]["build"] !== "string") throw new Error("A JavaScript package needs an explicitly supported build command");
+	switch (supportedPublishBuildCommand(manifest["scripts"]["build"])) {
+		case "vite": return await resolveVitePublishTarget(directory);
+		case "nuxt-module-build": return resolveNuxtPublishTarget(directory);
+		case "tsdown": break;
+	}
+	const configFiles = [
+		"ts",
+		"mts",
+		"cts",
+		"js",
+		"mjs",
+		"cjs",
+		"json"
+	].map((extension) => node_path.default.join(directory, `tsdown.config.${extension}`)).filter(node_fs.existsSync);
+	if (configFiles.length !== 1) throw new Error("Publish target resolver requires exactly one tsdown configuration");
+	const configFile = configFiles.at(0);
+	if (configFile === void 0) throw new Error("Missing tsdown configuration");
+	const require = (0, node_module.createRequire)(node_path.default.join(directory, "package.json"));
+	const metadata = JSON.parse((0, node_fs.readFileSync)(require.resolve("tsdown/package.json"), "utf8"));
+	if (!record(metadata) || metadata["version"] !== supportedTsdownVersion) throw new Error(`Publish target resolver supports tsdown ${supportedTsdownVersion}; review the adapter before changing build tools`);
+	const loaderRequire = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+	const scratch = (0, node_fs.mkdtempSync)(node_path.default.join((0, node_os.tmpdir)(), "stll-publish-target-"));
+	try {
+		const resultFile = node_path.default.join(scratch, "targets.json");
+		const result = (0, node_child_process.spawnSync)(process.versions.bun ? "node" : process.execPath, [
+			"--import",
+			(0, node_url.pathToFileURL)(loaderRequire.resolve("tsx")).href,
+			"--input-type=module",
+			"--eval",
+			tsdownConfigProcess,
+			JSON.stringify({
+				directory,
+				configFile,
+				toolUrl: (0, node_url.pathToFileURL)(require.resolve("tsdown")).href,
+				resultFile
+			})
+		], {
+			cwd: directory,
+			encoding: "utf8",
+			timeout: 3e4,
+			maxBuffer: 1024 * 1024
+		});
+		if (result.error) throw result.error;
+		if (result.status !== 0) throw new Error(`Node tsdown configuration resolver failed: ${result.stderr.trim()}`);
+		const resolved = JSON.parse((0, node_fs.readFileSync)(resultFile, "utf8"));
+		return resolvedTsdownTarget(resolved);
+	} finally {
+		(0, node_fs.rmSync)(scratch, {
+			recursive: true,
+			force: true
+		});
+	}
+};
+const tsdownConfigProcess = `
+import { readFileSync, writeFileSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+const { directory, configFile, toolUrl, resultFile } = JSON.parse(process.argv[1]);
+const record = value => typeof value === 'object' && value !== null && !Array.isArray(value);
+const tool = await import(toolUrl);
+if (typeof tool.resolveUserConfig !== 'function')
+  throw new Error('Installed tsdown does not expose its configuration resolver');
+if (tool.globalLogger) tool.globalLogger.level = 'silent';
+const loaded = configFile.endsWith('.json')
+  ? { default: JSON.parse(readFileSync(configFile, 'utf8')) }
+  : await import(pathToFileURL(configFile).href);
+if (!record(loaded)) throw new Error('Invalid tsdown module');
+const exported = loaded.default;
+if (typeof exported === 'function')
+  throw new Error('Dynamic root tsdown configurations require a supported target resolver');
+const configs = Array.isArray(exported) ? exported : [exported];
+const resolved = [];
+const assertTsdownBuildExtensions = ${assertTsdownBuildExtensions.toString()};
+for (const config of configs) {
+  if (!record(config)) throw new Error('tsdown configurations must be objects');
+  assertTsdownBuildExtensions(config);
+  if (config.cwd !== undefined || config.workspace !== undefined || config.fromVite !== undefined)
+    throw new Error('Relocated or inherited build configurations require a supported target resolver');
+  const output = await tool.resolveUserConfig(
+    { ...config, cwd: directory, logLevel: 'silent' }, { cwd: directory }, new Set(),
+  );
+  if (!Array.isArray(output)) throw new Error('Invalid tsdown resolved configuration');
+  for (const entry of output) {
+    if (!record(entry)) throw new Error('Invalid resolved tsdown configuration');
+    assertTsdownBuildExtensions(entry);
+    const input = entry.inputOptions;
+    if (input !== undefined && !record(input))
+      throw new Error('Dynamic tsdown inputOptions require a supported target resolver');
+    const transform = record(input) ? input.transform : undefined;
+    if (transform !== undefined && !record(transform))
+      throw new Error('tsdown transform overrides must be an object');
+    const target = record(transform) && transform.target != null ? transform.target : entry.target;
+    const nonemptyIdentifiers = value => typeof value === 'string' && value.trim() !== '' && !value.includes(',');
+    if (target !== undefined && !nonemptyIdentifiers(target) &&
+        !(Array.isArray(target) && target.length > 0 && Array.from(target).every(nonemptyIdentifiers)))
+      throw new Error('Build tool returned an unsupported resolved JavaScript target');
+    resolved.push({ target, dts: { emitDtsOnly: record(entry.dts) && entry.dts.emitDtsOnly === true } });
+  }
+}
+writeFileSync(resultFile, JSON.stringify(resolved));
+`;
+//#endregion
+//#region src/publish-contract-cli.ts
+const root = process.cwd();
+const main = async () => {
+	const args = process.argv.slice(2);
+	if (args.length === 1 && args.at(0) === "--help") process.stdout.write("Usage: stll-publish-contract [--write]\n");
+	else {
+		if (args.length > 1 || args.length === 1 && args.at(0) !== "--write") throw new Error("Expected no arguments or --write");
+		const write = args.at(0) === "--write";
+		const policy = require_toolchain_schema.parseToolchainPolicy(JSON.parse((0, node_fs.readFileSync)(new URL("../toolchain.json", require("url").pathToFileURL(__filename).href), "utf8")));
+		const consumer = {
+			node: policy.consumerNode,
+			typescript: policy.consumerTypescript
+		};
+		const tracked = (0, node_child_process.execFileSync)("git", ["ls-files", "-z"], {
+			cwd: root,
+			encoding: "utf8"
+		}).split("\0");
+		const files = {};
+		for (const file of tracked) {
+			if (file.split("/").some((part) => part === "node_modules" || part === ".git") || !["package.json", "pnpm-workspace.yaml"].includes(node_path.default.posix.basename(file)) && require_toolchain_inputs.githubAutomationFileKind(file) !== "workflow") continue;
+			files[file] = (0, node_fs.readFileSync)(node_path.default.join(root, file), "utf8");
+		}
+		const manifests = require_toolchain_schema.discoverConsumerManifests(files);
+		const names = /* @__PURE__ */ new Set();
+		for (const manifest of manifests.values()) {
+			const name = manifest["name"];
+			if (typeof name !== "string" || name === "") continue;
+			if (names.has(name)) throw new Error(`duplicate workspace package: ${name}`);
+			names.add(name);
+		}
+		let checked = 0;
+		for (const [relative, manifest] of [...manifests].sort(([left], [right]) => left.localeCompare(right))) {
+			const file = node_path.default.posix.join(relative, "package.json");
+			if (manifest["private"] === true) continue;
+			if (relative.split("/").includes("vendor")) throw new Error(`Published workspace packages under vendor directories are not supported by publish-contract: ${file}; move the package to a supported workspace directory`);
+			require_toolchain_schema.assertConsumerPublishableManifest({
+				manifest,
+				directory: relative
+			});
+			checked++;
+			const directory = node_path.default.dirname(node_path.default.join(root, file));
+			const contractFile = node_path.default.join(directory, "publish-contract.json");
+			const packer = require_publish_contract.resolveConsumerReleasePack(files).manager;
+			const target = await resolvePublishBuildTarget(directory, packer);
+			const current = require_publish_contract.resolveManifestContract({
+				manifest,
+				target,
+				packer
+			});
+			const diagnostics = require_publish_contract.checkPublishContract({
+				packer,
+				manifest,
+				target,
+				contract: write ? current : JSON.parse((0, node_fs.readFileSync)(contractFile, "utf8")),
+				policy: consumer
+			});
+			for (const diagnostic of diagnostics) process.stderr.write(`${file}:1: [publish-contract] ${diagnostic.message}\n`);
+			if (diagnostics.length > 0) {
+				process.exitCode = 1;
+				continue;
+			}
+			if (write) (0, node_fs.writeFileSync)(contractFile, `${JSON.stringify(current, null, 2)}\n`);
+		}
+		if (checked === 0) throw new Error("No published workspace packages found");
+	}
+};
+main().catch((error) => {
+	process.stderr.write(`publish-contract:1: ${error instanceof Error ? error.message : String(error)}\n`);
+	process.exitCode = 1;
+});
+//#endregion
+
+//# sourceMappingURL=publish-contract-cli.cjs.map