forge-pack 0.1.0

package/dist/cli-Dc4X1WbF.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import { i as resolveLibraries, n as generateDeployer, r as parseArtifact, t as findArtifact } from "./pack-A6vKuf56.js";
+import { parseArgs } from "node:util";
+import { execSync } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+//#region src/cli.ts
+const { values, positionals } = parseArgs({
+	allowPositionals: true,
+	options: {
+		out: {
+			type: "string",
+			default: "./out"
+		},
+		output: {
+			type: "string",
+			default: "./deployers"
+		},
+		build: {
+			type: "boolean",
+			default: false
+		},
+		solc: { type: "string" },
+		pragma: {
+			type: "string",
+			default: ">=0.8.0"
+		},
+		help: {
+			type: "boolean",
+			short: "h",
+			default: false
+		}
+	}
+});
+if (values.help || positionals.length === 0) {
+	console.log(`Usage: forge-pack <ContractName> [options]
+
+Options:
+  --out <dir>        Forge output directory (default: ./out)
+  --output <dir>     Where to write the deployer .sol file (default: ./deployers)
+  --build            Run \`forge build\` before reading artifacts
+  --solc <version>   Filter artifact by solc version (when multiple exist)
+  --pragma <range>   Solidity pragma for generated file (default: >=0.8.0)
+  -h, --help         Show this help message`);
+	process.exit(values.help ? 0 : 1);
+}
+const contractName = positionals[0];
+const outDir = resolve(values.out);
+const outputDir = resolve(values.output);
+const pragma = values.pragma;
+if (values.build) {
+	console.log("Running forge build...");
+	execSync("forge build", { stdio: "inherit" });
+}
+try {
+	const parsed = parseArtifact(findArtifact(contractName, outDir, { solcVersion: values.solc }), contractName);
+	if (!parsed.bytecode) {
+		console.error(`Error: No bytecode found for "${contractName}". Is it an abstract contract or interface?`);
+		process.exit(1);
+	}
+	const hasLinks = Object.keys(parsed.linkReferences).length > 0;
+	let libraries;
+	if (hasLinks) {
+		libraries = resolveLibraries(parsed.linkReferences, outDir);
+		const libNames = libraries.map((l) => l.lib);
+		console.log(`Resolved ${libNames.length} library dep(s): ${libNames.join(", ")}`);
+	}
+	const solidity = generateDeployer(parsed, {
+		pragma,
+		libraries
+	});
+	mkdirSync(outputDir, { recursive: true });
+	const outPath = join(outputDir, `${contractName}Deployer.sol`);
+	writeFileSync(outPath, solidity);
+	console.log(`Generated ${outPath}`);
+} catch (err) {
+	console.error(`Error: ${err.message}`);
+	process.exit(1);
+}
+
+//#endregion
+export {  };

package/dist/index-ECFAYGrl.d.ts

@@ -0,0 +1,68 @@
+//#region src/pack.d.ts
+interface LinkReference {
+  start: number;
+  length: number;
+}
+interface LinkReferences {
+  [file: string]: {
+    [lib: string]: LinkReference[];
+  };
+}
+interface AbiParam {
+  name: string;
+  type: string;
+  internalType?: string;
+  components?: AbiParam[];
+  indexed?: boolean;
+}
+interface AbiEntry {
+  type: string;
+  name?: string;
+  inputs?: AbiParam[];
+  outputs?: AbiParam[];
+  stateMutability?: string;
+}
+interface ParsedArtifact {
+  contractName: string;
+  abi: AbiEntry[];
+  bytecode: string;
+  linkReferences: LinkReferences;
+  sourcePath?: string;
+  solcVersion?: string;
+  optimizerRuns?: number;
+  viaIR?: boolean;
+  evmVersion?: string;
+}
+interface FindArtifactOptions {
+  solcVersion?: string;
+}
+/**
+ * A library dependency resolved from linkReferences, with its own parsed
+ * artifact and the param name used in generated code.
+ */
+interface ResolvedLibrary {
+  /** Parameter-style name, e.g. "mathLib" */
+  paramName: string;
+  /** Source file declaring the library, e.g. "src/libs/MathLib.sol" */
+  file: string;
+  /** Library contract name, e.g. "MathLib" */
+  lib: string;
+  /** Parsed artifact for this library */
+  artifact: ParsedArtifact;
+  /** Param names of libraries this library depends on (its own linkReferences) */
+  deps: string[];
+}
+declare function findArtifact(contractName: string, outDir: string, options?: FindArtifactOptions): string;
+declare function parseArtifact(artifactPath: string, contractName: string): ParsedArtifact;
+/**
+ * Recursively resolve all library dependencies for a contract's linkReferences.
+ * Returns libraries in topological order (deploy-order: leaves first).
+ */
+declare function resolveLibraries(linkRefs: LinkReferences, outDir: string): ResolvedLibrary[];
+interface GenerateDeployerOptions {
+  pragma?: string;
+  libraries?: ResolvedLibrary[];
+}
+declare function generateDeployer(parsed: ParsedArtifact, pragmaOrOpts?: string | GenerateDeployerOptions): string;
+//#endregion
+export { type AbiEntry, type AbiParam, type FindArtifactOptions, type GenerateDeployerOptions, type LinkReference, type LinkReferences, type ParsedArtifact, type ResolvedLibrary, findArtifact, generateDeployer, parseArtifact, resolveLibraries };

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+//#region src/pack.d.ts
+interface LinkReference {
+  start: number;
+  length: number;
+}
+interface LinkReferences {
+  [file: string]: {
+    [lib: string]: LinkReference[];
+  };
+}
+interface AbiParam {
+  name: string;
+  type: string;
+  internalType?: string;
+  components?: AbiParam[];
+  indexed?: boolean;
+}
+interface AbiEntry {
+  type: string;
+  name?: string;
+  inputs?: AbiParam[];
+  outputs?: AbiParam[];
+  stateMutability?: string;
+}
+interface ParsedArtifact {
+  contractName: string;
+  abi: AbiEntry[];
+  bytecode: string;
+  linkReferences: LinkReferences;
+  sourcePath?: string;
+  solcVersion?: string;
+  optimizerRuns?: number;
+  viaIR?: boolean;
+  evmVersion?: string;
+}
+interface FindArtifactOptions {
+  solcVersion?: string;
+}
+/**
+ * A library dependency resolved from linkReferences, with its own parsed
+ * artifact and the param name used in generated code.
+ */
+interface ResolvedLibrary {
+  /** Parameter-style name, e.g. "mathLib" */
+  paramName: string;
+  /** Source file declaring the library, e.g. "src/libs/MathLib.sol" */
+  file: string;
+  /** Library contract name, e.g. "MathLib" */
+  lib: string;
+  /** Parsed artifact for this library */
+  artifact: ParsedArtifact;
+  /** Param names of libraries this library depends on (its own linkReferences) */
+  deps: string[];
+}
+declare function findArtifact(contractName: string, outDir: string, options?: FindArtifactOptions): string;
+declare function parseArtifact(artifactPath: string, contractName: string): ParsedArtifact;
+/**
+ * Recursively resolve all library dependencies for a contract's linkReferences.
+ * Returns libraries in topological order (deploy-order: leaves first).
+ */
+declare function resolveLibraries(linkRefs: LinkReferences, outDir: string): ResolvedLibrary[];
+interface GenerateDeployerOptions {
+  pragma?: string;
+  libraries?: ResolvedLibrary[];
+}
+declare function generateDeployer(parsed: ParsedArtifact, pragmaOrOpts?: string | GenerateDeployerOptions): string;
+//#endregion
+export { type AbiEntry, type AbiParam, type FindArtifactOptions, type GenerateDeployerOptions, type LinkReference, type LinkReferences, type ParsedArtifact, type ResolvedLibrary, findArtifact, generateDeployer, parseArtifact, resolveLibraries };

package/dist/index.js

@@ -0,0 +1,3 @@
+import { i as resolveLibraries, n as generateDeployer, r as parseArtifact, t as findArtifact } from "./pack-A6vKuf56.js";
+
+export { findArtifact, generateDeployer, parseArtifact, resolveLibraries };

package/dist/pack-A6vKuf56.js

@@ -0,0 +1,331 @@
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+//#region src/pack.ts
+function findArtifact(contractName, outDir, options) {
+	const candidates = [];
+	const entries = readdirSync(outDir);
+	for (const entry of entries) {
+		const entryPath = join(outDir, entry);
+		if (!statSync(entryPath).isDirectory()) continue;
+		const jsonPath = join(entryPath, `${contractName}.json`);
+		try {
+			statSync(jsonPath);
+			candidates.push(jsonPath);
+		} catch {}
+	}
+	if (candidates.length === 0) throw new Error(`No artifact found for "${contractName}" in ${outDir}. Run \`forge build\` first.`);
+	if (options?.solcVersion && candidates.length > 1) {
+		for (const c of candidates) if ((JSON.parse(readFileSync(c, "utf-8"))?.metadata?.compiler?.version)?.startsWith(options.solcVersion)) return c;
+		throw new Error(`No artifact for "${contractName}" compiled with solc ${options.solcVersion}.`);
+	}
+	if (candidates.length > 1) throw new Error(`Multiple artifacts found for "${contractName}". Use --solc to disambiguate:\n` + candidates.map((c) => `  ${c}`).join("\n"));
+	return candidates[0];
+}
+function parseArtifact(artifactPath, contractName) {
+	const raw = JSON.parse(readFileSync(artifactPath, "utf-8"));
+	const abi = raw.abi ?? [];
+	let bytecodeHex = raw.bytecode?.object ?? "";
+	if (bytecodeHex.startsWith("0x")) bytecodeHex = bytecodeHex.slice(2);
+	const linkReferences = raw.bytecode?.linkReferences ?? {};
+	const metadata = raw.metadata;
+	const solcVersion = metadata?.compiler?.version;
+	const settings = metadata?.settings;
+	const optimizerRuns = settings?.optimizer?.runs;
+	const viaIR = settings?.viaIR;
+	const evmVersion = settings?.evmVersion;
+	let sourcePath;
+	if (metadata?.settings?.compilationTarget) {
+		const targets = metadata.settings.compilationTarget;
+		sourcePath = Object.keys(targets)[0];
+	}
+	return {
+		contractName,
+		abi,
+		bytecode: bytecodeHex,
+		linkReferences,
+		sourcePath,
+		solcVersion,
+		optimizerRuns,
+		viaIR,
+		evmVersion
+	};
+}
+/**
+* Collect unique library identities from linkReferences.
+* Returns deduped entries as { file, lib } pairs.
+*/
+function collectLibIds(linkRefs) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const [file, libs] of Object.entries(linkRefs)) for (const lib of Object.keys(libs)) {
+		const key = `${file}:${lib}`;
+		if (!seen.has(key)) {
+			seen.add(key);
+			result.push({
+				file,
+				lib
+			});
+		}
+	}
+	return result;
+}
+function makeParamName(libName) {
+	return libName.charAt(0).toLowerCase() + libName.slice(1);
+}
+/**
+* Recursively resolve all library dependencies for a contract's linkReferences.
+* Returns libraries in topological order (deploy-order: leaves first).
+*/
+function resolveLibraries(linkRefs, outDir) {
+	const resolved = /* @__PURE__ */ new Map();
+	const visiting = /* @__PURE__ */ new Set();
+	function resolve(file, lib) {
+		const key = `${file}:${lib}`;
+		if (resolved.has(key)) return resolved.get(key);
+		if (visiting.has(key)) throw new Error(`Circular library dependency detected: ${key}`);
+		visiting.add(key);
+		const artifact = parseArtifact(findArtifact(lib, outDir), lib);
+		const libIds = collectLibIds(artifact.linkReferences);
+		const deps = [];
+		for (const dep of libIds) {
+			const depResolved = resolve(dep.file, dep.lib);
+			deps.push(depResolved.paramName);
+		}
+		visiting.delete(key);
+		const entry = {
+			paramName: makeParamName(lib),
+			file,
+			lib,
+			artifact,
+			deps
+		};
+		resolved.set(key, entry);
+		return entry;
+	}
+	const topLevel = collectLibIds(linkRefs);
+	for (const { file, lib } of topLevel) resolve(file, lib);
+	return Array.from(resolved.values());
+}
+function extractStructName(internalType) {
+	let name = internalType.replace(/^struct\s+/, "");
+	name = name.replace(/(\[\d*\])+$/, "");
+	const dotIdx = name.lastIndexOf(".");
+	if (dotIdx !== -1) name = name.slice(dotIdx + 1);
+	return name;
+}
+function collectStructDefs(params) {
+	const seen = /* @__PURE__ */ new Map();
+	function walk(param) {
+		const it = param.internalType ?? "";
+		if (!it.startsWith("struct ") || !param.components) return;
+		for (const comp of param.components) walk(comp);
+		const name = extractStructName(it);
+		if (seen.has(name)) return;
+		const fields = param.components.map((comp, i) => ({
+			type: abiTypeToSolidity(comp),
+			name: comp.name || `field${i}`
+		}));
+		seen.set(name, {
+			name,
+			fields
+		});
+	}
+	for (const p of params) walk(p);
+	return Array.from(seen.values());
+}
+function abiTypeToSolidity(param) {
+	if (param.internalType) {
+		const it = param.internalType;
+		if (it.startsWith("contract ")) return "address";
+		if (it.startsWith("enum ")) return param.type;
+		if (it.startsWith("struct ")) return extractStructName(it) + param.type.replace(/^tuple/, "");
+		return it;
+	}
+	return param.type;
+}
+function formatParamWithStructs(param, index, structNames) {
+	const solType = abiTypeToSolidity(param);
+	return `${solType}${needsMemoryLocation(solType) || isStructType(solType, structNames) ? " memory" : ""} ${param.name || `arg${index}`}`;
+}
+function needsMemoryLocation(solType) {
+	if (solType === "string" || solType === "bytes") return true;
+	if (solType.endsWith("[]") || /\[\d+\]$/.test(solType)) return true;
+	return false;
+}
+function isStructType(solType, structNames) {
+	const baseName = solType.replace(/(\[\d*\])+$/, "");
+	return structNames.has(baseName);
+}
+function buildBytecodeSegments(bytecode, linkReferences) {
+	const placeholders = [];
+	for (const [file, libs] of Object.entries(linkReferences)) for (const [lib, refs] of Object.entries(libs)) for (const ref of refs) placeholders.push({
+		start: ref.start,
+		length: ref.length,
+		file,
+		lib
+	});
+	placeholders.sort((a, b) => a.start - b.start);
+	if (placeholders.length === 0) return {
+		segments: [{
+			type: "hex",
+			value: bytecode
+		}],
+		libParams: []
+	};
+	const libMap = /* @__PURE__ */ new Map();
+	const libParams = [];
+	for (const p of placeholders) {
+		const key = `${p.file}:${p.lib}`;
+		if (!libMap.has(key)) {
+			const paramName = makeParamName(p.lib);
+			libMap.set(key, paramName);
+			libParams.push({
+				name: paramName,
+				file: p.file,
+				lib: p.lib
+			});
+		}
+	}
+	const segments = [];
+	let cursor = 0;
+	for (const p of placeholders) {
+		const hexStart = p.start * 2;
+		const hexEnd = (p.start + p.length) * 2;
+		if (hexStart > cursor) segments.push({
+			type: "hex",
+			value: bytecode.slice(cursor, hexStart)
+		});
+		const key = `${p.file}:${p.lib}`;
+		segments.push({
+			type: "lib",
+			value: libMap.get(key)
+		});
+		cursor = hexEnd;
+	}
+	if (cursor < bytecode.length) segments.push({
+		type: "hex",
+		value: bytecode.slice(cursor)
+	});
+	return {
+		segments,
+		libParams
+	};
+}
+function renderInitcodeBody(bytecode, segments, hasLinks) {
+	if (!hasLinks) return `        return hex"${bytecode}";`;
+	return `        return abi.encodePacked(${segments.map((seg) => seg.type === "hex" ? `hex"${seg.value}"` : seg.value).join(", ")});`;
+}
+function generateDeployer(parsed, pragmaOrOpts) {
+	const opts = typeof pragmaOrOpts === "string" ? { pragma: pragmaOrOpts } : pragmaOrOpts ?? {};
+	const pragma = opts.pragma ?? ">=0.8.0";
+	const resolvedLibs = opts.libraries ?? [];
+	const { contractName, abi, bytecode, linkReferences } = parsed;
+	const libName = `${contractName}Deployer`;
+	const ctorParams = abi.find((e) => e.type === "constructor")?.inputs ?? [];
+	const structDefs = collectStructDefs(ctorParams);
+	const structNames = new Set(structDefs.map((s) => s.name));
+	const { segments: mainSegments, libParams: mainLibParams } = buildBytecodeSegments(bytecode, linkReferences);
+	const hasLinks = mainLibParams.length > 0;
+	const inlineLibs = hasLinks && resolvedLibs.length > 0;
+	const metaLines = [];
+	if (parsed.sourcePath) metaLines.push(`@notice Source Contract: ${parsed.sourcePath}`);
+	if (parsed.solcVersion) metaLines.push(`- solc: ${parsed.solcVersion}`);
+	if (parsed.optimizerRuns !== void 0) metaLines.push(`- optimizer_runs: ${parsed.optimizerRuns}`);
+	if (parsed.viaIR) metaLines.push(`- viaIR: true`);
+	if (parsed.evmVersion) metaLines.push(`- evm_version: ${parsed.evmVersion}`);
+	const metaBlock = metaLines.length > 0 ? [
+		`    /**`,
+		`     * @dev autogenerated by forge-pack`,
+		`     *`,
+		...metaLines.map((l) => `     * ${l}`),
+		`     */`
+	].join("\n") + "\n" : "";
+	const structBlock = structDefs.map((s) => {
+		const fields = s.fields.map((f) => `        ${f.type} ${f.name};`).join("\n");
+		return `    struct ${s.name} {\n${fields}\n    }`;
+	}).join("\n\n");
+	const initcodeParams = hasLinks ? mainLibParams.map((lp) => `address ${lp.name}`).join(", ") : "";
+	const initcodeBody = renderInitcodeBody(bytecode, mainSegments, hasLinks);
+	const libInitcodeFns = [];
+	if (inlineLibs) for (const rlib of resolvedLibs) {
+		const { segments: libSegs, libParams: libLibParams } = buildBytecodeSegments(rlib.artifact.bytecode, rlib.artifact.linkReferences);
+		const libHasLinks = libLibParams.length > 0;
+		const fnParams = libHasLinks ? libLibParams.map((lp) => `address ${lp.name}`).join(", ") : "";
+		const fnBody = renderInitcodeBody(rlib.artifact.bytecode, libSegs, libHasLinks);
+		libInitcodeFns.push(`    function _${rlib.paramName}Initcode(${fnParams}) private pure returns (bytes memory) {\n${fnBody}\n    }`);
+	}
+	const deployParams = [];
+	for (let i = 0; i < ctorParams.length; i++) deployParams.push(formatParamWithStructs(ctorParams[i], i, structNames));
+	if (hasLinks && !inlineLibs) for (const lp of mainLibParams) deployParams.push(`address ${lp.name}`);
+	const deployParamStr = deployParams.join(", ");
+	const deployBodyLines = [];
+	if (inlineLibs) for (const rlib of resolvedLibs) {
+		const { libParams: libLibParams } = buildBytecodeSegments(rlib.artifact.bytecode, rlib.artifact.linkReferences);
+		const callArgs = libLibParams.length > 0 ? libLibParams.map((lp) => lp.name).join(", ") : "";
+		deployBodyLines.push(`        address ${rlib.paramName} = _create(_${rlib.paramName}Initcode(${callArgs}));`);
+	}
+	const initcodeCallArgs = hasLinks ? mainLibParams.map((lp) => lp.name).join(", ") : "";
+	if (ctorParams.length > 0) {
+		const encodeArgs = ctorParams.map((p, i) => p.name || `arg${i}`).join(", ");
+		deployBodyLines.push(`        bytes memory args = abi.encode(${encodeArgs});`);
+		deployBodyLines.push(`        bytes memory initcode_ = abi.encodePacked(initcode(${initcodeCallArgs}), args);`);
+		deployBodyLines.push(`        deployed = _create(initcode_);`);
+	} else {
+		deployBodyLines.push(`        bytes memory initcode_ = initcode(${initcodeCallArgs});`);
+		deployBodyLines.push(`        deployed = _create(initcode_);`);
+	}
+	const deployBody = deployBodyLines.join("\n");
+	const deploy2BodyLines = [];
+	if (inlineLibs) for (const rlib of resolvedLibs) {
+		const { libParams: libLibParams } = buildBytecodeSegments(rlib.artifact.bytecode, rlib.artifact.linkReferences);
+		const callArgs = libLibParams.length > 0 ? libLibParams.map((lp) => lp.name).join(", ") : "";
+		deploy2BodyLines.push(`        address ${rlib.paramName} = _create(_${rlib.paramName}Initcode(${callArgs}));`);
+	}
+	if (ctorParams.length > 0) {
+		const encodeArgs = ctorParams.map((p, i) => p.name || `arg${i}`).join(", ");
+		deploy2BodyLines.push(`        bytes memory args = abi.encode(${encodeArgs});`);
+		deploy2BodyLines.push(`        bytes memory initcode_ = abi.encodePacked(initcode(${initcodeCallArgs}), args);`);
+		deploy2BodyLines.push(`        deployed = _create2(initcode_, salt);`);
+	} else {
+		deploy2BodyLines.push(`        bytes memory initcode_ = initcode(${initcodeCallArgs});`);
+		deploy2BodyLines.push(`        deployed = _create2(initcode_, salt);`);
+	}
+	const deploy2Body = deploy2BodyLines.join("\n");
+	const deploy2Params = deployParams.length > 0 ? `${deployParamStr}, bytes32 salt` : `bytes32 salt`;
+	return `// SPDX-License-Identifier: MIT
+pragma solidity ${pragma};
+
+library ${libName} {
+${metaBlock}${structBlock ? `\n${structBlock}\n` : ""}
+    function deploy(${deployParamStr}) internal returns (address deployed) {
+${deployBody}
+    }
+
+    function deploy2(${deploy2Params}) internal returns (address deployed) {
+${deploy2Body}
+    }
+
+    function initcode(${initcodeParams}) internal pure returns (bytes memory) {
+${initcodeBody}
+    }
+${libInitcodeFns.length > 0 ? "\n" + libInitcodeFns.join("\n\n") + "\n" : ""}
+    function _create(bytes memory initcode_) private returns (address deployed) {
+        assembly {
+            deployed := create(0, add(initcode_, 0x20), mload(initcode_))
+            if iszero(deployed) { revert(0, returndatasize()) }
+        }
+    }
+
+    function _create2(bytes memory initcode_, bytes32 salt) private returns (address deployed) {
+        assembly {
+            deployed := create2(0, add(initcode_, 0x20), mload(initcode_), salt)
+            if iszero(deployed) { revert(0, returndatasize()) }
+        }
+    }
+}
+`;
+}
+
+//#endregion
+export { resolveLibraries as i, generateDeployer as n, parseArtifact as r, findArtifact as t };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "forge-pack",
+  "version": "0.1.0",
+  "description": "Generate self-contained Solidity deployer files from Forge build artifacts",
+  "type": "module",
+  "bin": {
+    "forge-pack": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "forge",
+    "foundry",
+    "solidity",
+    "deployer",
+    "bytecode"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "tsdown": "^0.12.5",
+    "typescript": "^5.8.3",
+    "@types/node": "^24.10.13"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown && node -e \"const fs=require('fs'),p=require('path'),d='dist';fs.readdirSync(d).filter(f=>f.startsWith('index-')&&f.endsWith('.d.ts')).forEach(f=>{fs.copyFileSync(p.join(d,f),p.join(d,'index.d.ts'))});const c=fs.readFileSync(p.join(d,'cli.js'),'utf8');fs.writeFileSync(p.join(d,'cli.js'),'#!/usr/bin/env node\\n'+c)\"",
+    "dev": "tsdown --watch"
+  }
+}