forge-pack 0.1.0 → 0.3.0

package/README.md

@@ -0,0 +1,88 @@
+# forge-pack
+
+Generate self-contained Solidity deployer libraries from [Forge](https://book.getfoundry.sh/) build artifacts.
+
+`forge-pack` reads your compiled contract JSON, resolves library dependencies, and outputs a single `.sol` file containing a deployer library with `deploy()`, `deploy2()` (CREATE2), and `initcode()` functions — ready to use in scripts or tests.
+
+## Usage
+
+The package does not require installation, you can directly use `npx`/`pnpx` to run it:
+
+```bash
+npx forge-pack@latest <contract-name>
+```
+
+## CLI Usage
+
+```
+forge-pack <ContractName> [options]
+```
+
+### Options
+
+| Flag               | Description                                | Default       |
+| ------------------ | ------------------------------------------ | ------------- |
+| `--out <dir>`      | Forge output directory                     | `./out`       |
+| `--output <dir>`   | Where to write the deployer `.sol` file    | `./deployers` |
+| `--build`          | Run `forge build` before reading artifacts | `false`       |
+| `--pragma <range>` | Solidity pragma for generated file         | `>=0.8.0`     |
+| `-h, --help`       | Show help message                          | —             |
+
+### Example
+
+```bash
+# Generate a deployer for MyToken
+forge-pack MyToken
+
+# Build first, then generate with a specific pragma
+forge-pack MyToken --build --pragma "^0.8.20"
+
+# Use a custom output directory
+forge-pack MyToken --output src/deployers
+```
+
+This produces a file like `deployers/MyTokenDeployer.sol`:
+
+```solidity
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.0;
+
+library MyTokenDeployer {
+    function deploy(string memory name, string memory symbol) internal returns (address deployed) { ... }
+    function deploy2(bytes32 salt, string memory name, string memory symbol) internal returns (address deployed) { ... }
+    function initcode(string memory name, string memory symbol) internal pure returns (bytes memory) { ... }
+}
+```
+
+Constructor parameters are automatically extracted from the ABI. Struct types used in constructor arguments get their definitions included in the generated file.
+
+## Library Dependencies
+
+If your contract links against external libraries, `forge-pack` resolves them recursively in topological order and generates inline deployment helpers. The deployer handles deploying libraries before the main contract, so the output remains self-contained.
+
+## Programmatic API
+
+```typescript
+import { findArtifact, parseArtifact, generateDeployer, resolveLibraries } from "forge-pack";
+
+const artifactPath = findArtifact("MyToken", "./out");
+const parsed = parseArtifact(artifactPath, "MyToken");
+
+const libraries = resolveLibraries(parsed.linkReferences, "./out");
+const solidity = generateDeployer(parsed, { pragma: ">=0.8.0", libraries });
+```
+
+### Exports
+
+**Functions:**
+
+- `findArtifact(contractName, outDir, options?)` — Locate a contract artifact in the Forge output directory
+- `parseArtifact(artifactPath, contractName)` — Parse a Forge artifact JSON into a structured object
+- `resolveLibraries(linkReferences, outDir)` — Recursively resolve library dependencies in deploy order
+- `generateDeployer(parsed, options?)` — Generate Solidity deployer library source code
+
+**Types:** `ParsedArtifact`, `LinkReference`, `LinkReferences`, `AbiParam`, `AbiEntry`, `FindArtifactOptions`, `ResolvedLibrary`, `GenerateDeployerOptions`
+
+## License
+
+MIT

package/dist/cli.d.mts

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

package/dist/cli.mjs

@@ -0,0 +1,134 @@
+import { i as parseArtifact, n as resolveLibraries, r as findArtifact, t as generateDeployer } from "./codegen--WByOfZu.mjs";
+import { parseArgs } from "node:util";
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+//#region src/deploy-helper.ts
+const DEPLOY_HELPER_SOL = `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+library DeployHelper {
+    function deploy(bytes memory initcode, bytes32 salt) internal returns (address contractAddress) {
+        assembly ("memory-safe") {
+            contractAddress := create2(callvalue(), add(initcode, 32), mload(initcode), salt)
+            if iszero(contractAddress) {
+                let ptr := mload(0x40)
+                let errorSize := returndatasize()
+                returndatacopy(ptr, 0, errorSize)
+                revert(ptr, errorSize)
+            }
+        }
+    }
+
+    function deploy(bytes memory initcode) internal returns (address contractAddress) {
+        contractAddress = deploy(initcode, bytes32(0));
+    }
+
+    /// @dev Deploys a library using CREATE2 with zero salt.
+    ///      If the library is already deployed (duplicate across contracts), returns the existing address.
+    function deployLibrary(bytes memory initcode) internal returns (address contractAddress) {
+        bytes32 salt = bytes32(0);
+        contractAddress = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, keccak256(initcode))))));
+        if (contractAddress.code.length > 0) return contractAddress;
+        contractAddress = deploy(initcode, salt);
+    }
+}
+`;
+
+//#endregion
+//#region src/cli.ts
+const pkgPath = new URL("../package.json", import.meta.url);
+const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+const { values, positionals } = parseArgs({
+	allowPositionals: true,
+	options: {
+		out: {
+			type: "string",
+			default: "./out"
+		},
+		output: {
+			type: "string",
+			default: "./deployers"
+		},
+		build: {
+			type: "boolean",
+			default: false
+		},
+		pragma: {
+			type: "string",
+			default: ">=0.8.0"
+		},
+		version: {
+			type: "boolean",
+			short: "v",
+			default: false
+		},
+		help: {
+			type: "boolean",
+			short: "h",
+			default: false
+		}
+	}
+});
+if (values.version) {
+	console.log(pkg.version);
+	process.exit(0);
+}
+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 files (default: ./deployers)
+  --build            Run \`forge build\` before reading artifacts
+  --pragma <range>   Solidity pragma for generated files (default: >=0.8.0)
+  -v, --version      Show version number
+  -h, --help         Show this help message`);
+	process.exit(values.help ? 0 : 1);
+}
+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" });
+}
+const utilsDir = join(outputDir, "utils");
+const deployHelperPath = join(utilsDir, "DeployHelper.sol");
+mkdirSync(utilsDir, { recursive: true });
+if (!existsSync(deployHelperPath)) {
+	writeFileSync(deployHelperPath, DEPLOY_HELPER_SOL);
+	console.log(`Generated ${deployHelperPath}`);
+}
+let hasError = false;
+for (const contractName of positionals) try {
+	const parsed = parseArtifact(findArtifact(contractName, outDir), contractName);
+	if (!parsed.bytecode) {
+		console.error(`Error: No bytecode found for "${contractName}". Is it an abstract contract or interface?`);
+		hasError = true;
+		continue;
+	}
+	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(`[${contractName}] 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 [${contractName}]: ${err.message}`);
+	hasError = true;
+}
+if (hasError) process.exit(1);
+
+//#endregion
+export {  };

package/dist/{pack-A6vKuf56.js → codegen--WByOfZu.mjs}

@@ -1,8 +1,8 @@
 import { readFileSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 
-//#region src/pack.ts
-function findArtifact(contractName, outDir, options) {
+//#region src/artifact.ts
+function findArtifact(contractName, outDir) {
 	const candidates = [];
 	const entries = readdirSync(outDir);
 	for (const entry of entries) {
@@ -15,11 +15,6 @@ function findArtifact(contractName, outDir, options) {
 		} 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) {
@@ -34,6 +29,7 @@ function parseArtifact(artifactPath, contractName) {
 	const optimizerRuns = settings?.optimizer?.runs;
 	const viaIR = settings?.viaIR;
 	const evmVersion = settings?.evmVersion;
+	const bytecodeHash = metadata?.settings?.metadata?.bytecodeHash ?? settings?.metadata?.bytecodeHash;
 	let sourcePath;
 	if (metadata?.settings?.compilationTarget) {
 		const targets = metadata.settings.compilationTarget;
@@ -48,13 +44,13 @@ function parseArtifact(artifactPath, contractName) {
 		solcVersion,
 		optimizerRuns,
 		viaIR,
-		evmVersion
+		evmVersion,
+		bytecodeHash
 	};
 }
-/**
-* Collect unique library identities from linkReferences.
-* Returns deduped entries as { file, lib } pairs.
-*/
+
+//#endregion
+//#region src/resolve.ts
 function collectLibIds(linkRefs) {
 	const seen = /* @__PURE__ */ new Set();
 	const result = [];
@@ -76,6 +72,7 @@ function makeParamName(libName) {
 /**
 * Recursively resolve all library dependencies for a contract's linkReferences.
 * Returns libraries in topological order (deploy-order: leaves first).
+* Disambiguates duplicate paramName values with numeric suffixes.
 */
 function resolveLibraries(linkRefs, outDir) {
 	const resolved = /* @__PURE__ */ new Map();
@@ -105,8 +102,31 @@ function resolveLibraries(linkRefs, outDir) {
 	}
 	const topLevel = collectLibIds(linkRefs);
 	for (const { file, lib } of topLevel) resolve(file, lib);
-	return Array.from(resolved.values());
+	const libs = Array.from(resolved.values());
+	const nameCount = /* @__PURE__ */ new Map();
+	for (const entry of libs) {
+		const count = nameCount.get(entry.paramName) ?? 0;
+		nameCount.set(entry.paramName, count + 1);
+	}
+	const collisions = /* @__PURE__ */ new Set();
+	for (const [name, count] of nameCount) if (count > 1) collisions.add(name);
+	if (collisions.size > 0) {
+		const nameIndex = /* @__PURE__ */ new Map();
+		for (const entry of libs) {
+			if (!collisions.has(entry.paramName)) continue;
+			const idx = (nameIndex.get(entry.paramName) ?? 0) + 1;
+			nameIndex.set(entry.paramName, idx);
+			if (idx > 1) entry.paramName = `${entry.paramName}${idx}`;
+		}
+		const keyToName = /* @__PURE__ */ new Map();
+		for (const entry of libs) keyToName.set(`${entry.file}:${entry.lib}`, entry.paramName);
+		for (const entry of libs) entry.deps = collectLibIds(entry.artifact.linkReferences).map((d) => keyToName.get(`${d.file}:${d.lib}`));
+	}
+	return libs;
 }
+
+//#endregion
+//#region src/codegen.ts
 function extractStructName(internalType) {
 	let name = internalType.replace(/^struct\s+/, "");
 	name = name.replace(/(\[\d*\])+$/, "");
@@ -216,13 +236,31 @@ 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 renderDeployBody(opts) {
+	const { inlineLibs, resolvedLibs, ctorParams, initcodeCallArgs } = opts;
+	const lines = [];
+	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(", ") : "";
+		lines.push(`        address ${rlib.paramName} = DeployHelper.deployLibrary(_${rlib.paramName}Initcode(${callArgs}));`);
+	}
+	if (ctorParams.length > 0) {
+		const encodeArgs = ctorParams.map((p, i) => p.name || `arg${i}`).join(", ");
+		lines.push(`        bytes memory args = abi.encode(${encodeArgs});`);
+		lines.push(`        bytes memory initcode_ = abi.encodePacked(initcode(${initcodeCallArgs}), args);`);
+	} else lines.push(`        bytes memory initcode_ = initcode(${initcodeCallArgs});`);
+	lines.push(`        deployed = DeployHelper.deploy(initcode_, salt);`);
+	return lines.join("\n");
+}
 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 ctorEntry = abi.find((e) => e.type === "constructor");
+	const ctorParams = ctorEntry?.inputs ?? [];
+	const isPayable = ctorEntry?.stateMutability === "payable";
 	const structDefs = collectStructDefs(ctorParams);
 	const structNames = new Set(structDefs.map((s) => s.name));
 	const { segments: mainSegments, libParams: mainLibParams } = buildBytecodeSegments(bytecode, linkReferences);
@@ -232,8 +270,9 @@ function generateDeployer(parsed, pragmaOrOpts) {
 	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`);
+	metaLines.push(`- viaIR: ${parsed.viaIR ?? false}`);
 	if (parsed.evmVersion) metaLines.push(`- evm_version: ${parsed.evmVersion}`);
+	metaLines.push(`- bytecodeHash: ${parsed.bytecodeHash ?? "ipfs"}`);
 	const metaBlock = metaLines.length > 0 ? [
 		`    /**`,
 		`     * @dev autogenerated by forge-pack`,
@@ -258,74 +297,33 @@ function generateDeployer(parsed, pragmaOrOpts) {
 	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 deployParamStr = deployParams.length > 0 ? `${deployParams.join(", ")}, bytes32 salt` : `bytes32 salt`;
 	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`;
+	const payableModifier = isPayable ? " payable" : "";
+	const deployBody = renderDeployBody({
+		inlineLibs,
+		resolvedLibs,
+		ctorParams,
+		initcodeCallArgs,
+		isPayable
+	});
 	return `// SPDX-License-Identifier: MIT
 pragma solidity ${pragma};
 
+import {DeployHelper} from "./utils/DeployHelper.sol";
+
 library ${libName} {
 ${metaBlock}${structBlock ? `\n${structBlock}\n` : ""}
-    function deploy(${deployParamStr}) internal returns (address deployed) {
+    function deploy(${deployParamStr}) internal${payableModifier} 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()) }
-        }
-    }
-}
+${libInitcodeFns.length > 0 ? "\n" + libInitcodeFns.join("\n\n") + "\n" : ""}}
 `;
 }
 
 //#endregion
-export { resolveLibraries as i, generateDeployer as n, parseArtifact as r, findArtifact as t };
+export { parseArtifact as i, resolveLibraries as n, findArtifact as r, generateDeployer as t };

package/dist/{index-ECFAYGrl.d.ts → index.d.mts}

@@ -1,4 +1,4 @@
-//#region src/pack.d.ts
+//#region src/types.d.ts
 interface LinkReference {
   start: number;
   length: number;
@@ -32,14 +32,8 @@ interface ParsedArtifact {
   optimizerRuns?: number;
   viaIR?: boolean;
   evmVersion?: string;
+  bytecodeHash?: 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;
@@ -52,17 +46,24 @@ interface ResolvedLibrary {
   /** Param names of libraries this library depends on (its own linkReferences) */
   deps: string[];
 }
-declare function findArtifact(contractName: string, outDir: string, options?: FindArtifactOptions): string;
+interface GenerateDeployerOptions {
+  pragma?: string;
+  libraries?: ResolvedLibrary[];
+}
+//#endregion
+//#region src/artifact.d.ts
+declare function findArtifact(contractName: string, outDir: string): string;
 declare function parseArtifact(artifactPath: string, contractName: string): ParsedArtifact;
+//#endregion
+//#region src/resolve.d.ts
 /**
  * Recursively resolve all library dependencies for a contract's linkReferences.
  * Returns libraries in topological order (deploy-order: leaves first).
+ * Disambiguates duplicate paramName values with numeric suffixes.
  */
 declare function resolveLibraries(linkRefs: LinkReferences, outDir: string): ResolvedLibrary[];
-interface GenerateDeployerOptions {
-  pragma?: string;
-  libraries?: ResolvedLibrary[];
-}
+//#endregion
+//#region src/codegen.d.ts
 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 };
+export { type AbiEntry, type AbiParam, type GenerateDeployerOptions, type LinkReference, type LinkReferences, type ParsedArtifact, type ResolvedLibrary, findArtifact, generateDeployer, parseArtifact, resolveLibraries };

package/dist/index.mjs

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

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "forge-pack",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Generate self-contained Solidity deployer files from Forge build artifacts",
   "type": "module",
   "bin": {
-    "forge-pack": "./dist/cli.js"
+    "forge-pack": "./dist/cli.mjs"
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
     }
   },
   "files": [
@@ -24,18 +24,30 @@
     "deployer",
     "bytecode"
   ],
-  "author": "",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/akshatmittal/forge-pack.git"
+  },
+  "author": "Akshat Mittal <hi@akshatmittal.com>",
   "license": "MIT",
   "devDependencies": {
-    "tsdown": "^0.12.5",
-    "typescript": "^5.8.3",
-    "@types/node": "^24.10.13"
+    "@changesets/changelog-github": "^0.5.2",
+    "@changesets/cli": "^2.29.8",
+    "@changesets/config": "^3.1.2",
+    "@types/node": "^24.10.13",
+    "prettier": "^3.8.1",
+    "tsdown": "^0.20.3",
+    "typescript": "^5.9.3"
   },
   "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"
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "changeset publish",
+    "format": "prettier --write \"**/*.{ts,tsx,md,json}\""
   }
 }

package/dist/cli-Dc4X1WbF.d.ts

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

package/dist/cli.js

@@ -1,83 +0,0 @@
-#!/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.d.ts

@@ -1,68 +0,0 @@
-//#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

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