soltag 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 morpho-org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,248 @@
+# soltag
+
+Inline Solidity in TypeScript. Write Solidity inside a tagged template literal, get real-time IDE type inference, and execute deployless reads via `eth_call` + `stateOverride`.
+
+```ts
+import { sol } from 'soltag';
+
+const contract = sol`
+  pragma solidity ^0.8.24;
+  interface IERC20 { function balanceOf(address) external view returns (uint256); }
+  library Lens {
+    function userBalances(address[] memory tokens, address user)
+      external view returns (uint256[] memory out)
+    {
+      out = new uint256[](tokens.length);
+      for (uint256 i = 0; i < tokens.length; i++) {
+        out[i] = IERC20(tokens[i]).balanceOf(user);
+      }
+    }
+  }
+`;
+
+const balances = await contract.call(client, 'userBalances', [[USDC, WETH], user]);
+//    ^? bigint[]                        ^? autocompletes    ^? typed args
+```
+
+## Features
+
+- **`sol` tagged template** — write Solidity inline, get a `SolContract` you can `.call()` against any RPC. Supports string interpolation for composing reusable fragments
+- **Real-time IDE support** — function name autocomplete, typed args, return type hover, inline Solidity diagnostics via a TypeScript Language Service Plugin (no codegen)
+- **Build-time compilation** — bundler plugin (Vite, Rollup, esbuild, webpack) compiles Solidity at build time so `solc` (8MB WASM) never ships to production
+- **Deployless execution** — uses `eth_call` with `stateOverride` to run contract code without deploying
+
+## Install
+
+```sh
+pnpm add soltag viem
+```
+
+For **runtime compilation** (scripts, REPLs, testing), also install `solc`:
+
+```sh
+pnpm add solc
+```
+
+For the **bundler plugin** (recommended for apps), install `solc` as a dev dependency along with `unplugin` and `magic-string`:
+
+```sh
+pnpm add -D solc unplugin magic-string
+```
+
+> **Note on `pragma solidity`:** The pragma in your Solidity source is a compatibility constraint checked by solc at compile time — it doesn't select a compiler version. As long as your installed `solc` version satisfies the pragma range (e.g. solc 0.8.28 satisfies `^0.8.24`), compilation proceeds. If it doesn't, solc will reject it with an error.
+
+## Setup
+
+### Bundler Plugin (recommended for apps)
+
+Compiles `sol` templates at build time — `solc` is only needed during the build, not at runtime.
+
+```ts
+// vite.config.ts
+import soltag from 'soltag/vite';
+
+export default defineConfig({
+  plugins: [soltag()],
+});
+```
+
+Also available for other bundlers:
+
+```ts
+import soltag from 'soltag/rollup';
+import soltag from 'soltag/esbuild';
+import soltag from 'soltag/webpack';
+```
+
+### TypeScript Plugin (IDE support)
+
+Add to your `tsconfig.json` for autocomplete, hover types, and inline Solidity diagnostics:
+
+```json
+{
+  "compilerOptions": {
+    "plugins": [{ "name": "soltag/plugin" }]
+  }
+}
+```
+
+> VS Code users: make sure your workspace is using the TypeScript version from `node_modules` (not the built-in one). Open a `.ts` file, click the TypeScript version in the bottom status bar, and select "Use Workspace Version".
+
+## Usage
+
+### Basic
+
+```ts
+import { sol } from 'soltag';
+import { createPublicClient, http } from 'viem';
+import { mainnet } from 'viem/chains';
+
+const client = createPublicClient({ chain: mainnet, transport: http() });
+
+const contract = sol`
+  pragma solidity ^0.8.24;
+  contract Math {
+    function add(uint256 a, uint256 b) external pure returns (uint256) {
+      return a + b;
+    }
+  }
+`;
+
+const result = await contract.call(client, 'add', [1n, 2n]);
+// result === 3n
+```
+
+### Reading on-chain state
+
+```ts
+const contract = sol`
+  pragma solidity ^0.8.24;
+  interface IERC20 {
+    function balanceOf(address) external view returns (uint256);
+    function decimals() external view returns (uint8);
+  }
+  library Lens {
+    function getBalance(address token, address user)
+      external view returns (uint256 balance, uint8 decimals)
+    {
+      balance = IERC20(token).balanceOf(user);
+      decimals = IERC20(token).decimals();
+    }
+  }
+`;
+
+const [balance, decimals] = await contract.call(client, 'getBalance', [USDC, user]);
+```
+
+### Composing with fragments
+
+The `sol` tag supports string interpolation, so you can define reusable Solidity fragments and compose them:
+
+```ts
+const IERC20 = `
+  interface IERC20 {
+    function balanceOf(address) external view returns (uint256);
+    function decimals() external view returns (uint8);
+  }
+`;
+
+const balanceLens = sol`
+  pragma solidity ^0.8.24;
+  ${IERC20}
+  contract BalanceLens {
+    function getBalance(address token, address user)
+      external view returns (uint256 balance, uint8 decimals)
+    {
+      balance = IERC20(token).balanceOf(user);
+      decimals = IERC20(token).decimals();
+    }
+  }
+`;
+
+const allowanceLens = sol`
+  pragma solidity ^0.8.24;
+  ${IERC20}
+  contract AllowanceLens {
+    function getAllowance(address token, address owner, address spender)
+      external view returns (uint256)
+    {
+      return IERC20(token).allowance(owner, spender);
+    }
+  }
+`;
+```
+
+The bundler plugin resolves `const` string interpolations at build time, so these templates are still compiled ahead of time. Interpolations that can't be statically resolved (e.g. variables from function calls) are left for runtime compilation.
+
+### Pre-compiled artifacts
+
+For environments where you want full control over the compilation step:
+
+```ts
+import { SolContract } from 'soltag';
+
+const contract = SolContract.fromArtifacts({
+  MyContract: {
+    abi: [/* ... */],
+    deployedBytecode: '0x...',
+    initBytecode: '0x...',
+  },
+});
+```
+
+## How It Works
+
+### Runtime path (scripts, testing)
+
+1. `sol` tag captures the Solidity source string
+2. On first `.call()`, compiles with `solc-js` (lazy-loaded) and caches the result
+3. Derives a deterministic address from the source hash
+4. Executes via `eth_call` with `stateOverride` — the contract bytecode is injected at the derived address without deploying
+5. Decodes the return value via viem's ABI decoder
+
+### Build-time path (apps with bundler plugin)
+
+1. The bundler plugin parses each file's AST to find `sol` tagged templates
+2. For templates with interpolations, resolves `const` string values statically
+3. Compiles the resolved Solidity with `solc-js` during the build
+4. Replaces `` sol`...` `` with `SolContract.fromArtifacts({...})` containing the pre-compiled ABI and bytecode
+5. At runtime, no compilation happens — only ABI encoding, `eth_call`, and decoding
+
+### IDE path (TypeScript Language Service Plugin)
+
+1. The TS plugin runs in `tsserver` (your editor's TypeScript process)
+2. It finds `sol` tagged templates, compiles them with solc-js, and extracts the ABI
+3. Provides function name completions for `.call()`, hover types showing Solidity-to-TypeScript mappings, and inline diagnostics for Solidity compilation errors
+
+## API
+
+### `sol`
+
+```ts
+function sol(strings: TemplateStringsArray, ...values: string[]): SolContract;
+```
+
+Tagged template literal. Accepts string interpolations for composing Solidity from reusable fragments.
+
+### `SolContract`
+
+```ts
+class SolContract {
+  // Create from pre-compiled artifacts (used by bundler plugin)
+  static fromArtifacts(artifacts: CompilationResult, sourceHash?: Hex): SolContract;
+
+  // Merged ABI across all contracts in the source
+  readonly abi: Abi;
+
+  // Execute a read-only call via stateOverride
+  call(client: PublicClient, functionName: string, args?: readonly unknown[]): Promise<unknown>;
+}
+```
+
+### `SolCompilationError`
+
+Thrown when Solidity compilation fails. Contains a `.errors` array of `SolcDiagnostic` objects with severity, message, and source location.
+
+## License
+
+MIT

package/dist/chunk-LNEBK5MP.js

@@ -0,0 +1,192 @@
+// src/build/unplugin.ts
+import MagicString from "magic-string";
+import ts from "typescript";
+import { createUnplugin } from "unplugin";
+
+// src/runtime/compiler.ts
+import { createRequire } from "module";
+import { keccak256, toHex } from "viem";
+
+// src/solc.ts
+function buildSolcInput(source) {
+  return {
+    language: "Solidity",
+    sources: {
+      "inline.sol": { content: source }
+    },
+    settings: {
+      optimizer: { enabled: true, runs: 1 },
+      outputSelection: {
+        "*": {
+          "*": ["abi", "evm.bytecode.object", "evm.deployedBytecode.object"]
+        }
+      }
+    }
+  };
+}
+
+// src/runtime/compiler.ts
+var require2 = createRequire(import.meta.url);
+var solcInstance;
+function getSolc() {
+  if (!solcInstance) {
+    try {
+      solcInstance = require2("solc");
+    } catch {
+      throw new Error(
+        "solc is not installed. Install it (`pnpm add solc`) for runtime compilation, or use the soltag bundler plugin for build-time compilation."
+      );
+    }
+  }
+  return solcInstance;
+}
+var SolCompilationError = class extends Error {
+  constructor(errors) {
+    const formatted = errors.map((e) => `${e.severity}: ${e.message}`).join("\n");
+    super(`Solidity compilation failed:
+${formatted}`);
+    this.errors = errors;
+    this.name = "SolCompilationError";
+  }
+};
+var compilationCache = /* @__PURE__ */ new Map();
+function hashSource(source) {
+  return keccak256(toHex(source));
+}
+function compile(source) {
+  const hash = hashSource(source);
+  const cached = compilationCache.get(hash);
+  if (cached) return cached;
+  const solc = getSolc();
+  const input = buildSolcInput(source);
+  const rawOutput = solc.compile(JSON.stringify(input));
+  const output = JSON.parse(rawOutput);
+  const diagnostics = toDiagnostics(output.errors);
+  const errors = diagnostics.filter((d) => d.severity === "error");
+  if (errors.length > 0) {
+    throw new SolCompilationError(errors);
+  }
+  const result = {};
+  if (output.contracts) {
+    for (const [, fileContracts] of Object.entries(output.contracts)) {
+      for (const [contractName, contractOutput] of Object.entries(fileContracts)) {
+        result[contractName] = {
+          abi: contractOutput.abi,
+          deployedBytecode: `0x${contractOutput.evm.deployedBytecode.object}`,
+          initBytecode: `0x${contractOutput.evm.bytecode.object}`
+        };
+      }
+    }
+  }
+  compilationCache.set(hash, result);
+  return result;
+}
+function toDiagnostics(errors) {
+  return (errors ?? []).map((e) => ({
+    severity: e.severity,
+    message: e.message,
+    formattedMessage: e.formattedMessage,
+    sourceLocation: e.sourceLocation
+  }));
+}
+
+// src/build/unplugin.ts
+function resolveStringExpression(node, sourceFile) {
+  if (ts.isStringLiteral(node)) return node.text;
+  if (ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  if (ts.isTemplateExpression(node)) {
+    let result = node.head.text;
+    for (const span of node.templateSpans) {
+      const resolved = resolveStringExpression(span.expression, sourceFile);
+      if (resolved === void 0) return void 0;
+      result += resolved + span.literal.text;
+    }
+    return result;
+  }
+  if (ts.isIdentifier(node)) {
+    return resolveIdentifierToString(node, sourceFile);
+  }
+  if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+    const left = resolveStringExpression(node.left, sourceFile);
+    const right = resolveStringExpression(node.right, sourceFile);
+    if (left !== void 0 && right !== void 0) return left + right;
+    return void 0;
+  }
+  return void 0;
+}
+function resolveIdentifierToString(identifier, sourceFile) {
+  const name = identifier.text;
+  for (const statement of sourceFile.statements) {
+    if (!ts.isVariableStatement(statement)) continue;
+    if (!(statement.declarationList.flags & ts.NodeFlags.Const)) continue;
+    for (const decl of statement.declarationList.declarations) {
+      if (ts.isIdentifier(decl.name) && decl.name.text === name && decl.initializer) {
+        return resolveStringExpression(decl.initializer, sourceFile);
+      }
+    }
+  }
+  return void 0;
+}
+function extractTemplateSource(template, sourceFile) {
+  if (ts.isNoSubstitutionTemplateLiteral(template)) {
+    return template.text;
+  }
+  let result = template.head.text;
+  for (const span of template.templateSpans) {
+    const resolved = resolveStringExpression(span.expression, sourceFile);
+    if (resolved === void 0) return void 0;
+    result += resolved + span.literal.text;
+  }
+  return result;
+}
+function transformSolTemplates(code, id) {
+  if (!code.includes("sol`") && !code.includes("sol `")) return void 0;
+  const sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true);
+  const s = new MagicString(code);
+  let hasReplacements = false;
+  function visit(node) {
+    if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && node.tag.text === "sol") {
+      const soliditySource = extractTemplateSource(node.template, sourceFile);
+      if (soliditySource === void 0) {
+        return;
+      }
+      const artifacts = compile(soliditySource);
+      const sourceHash = hashSource(soliditySource);
+      const replacement = `__SolContract.fromArtifacts(${JSON.stringify(artifacts)}, "${sourceHash}")`;
+      s.overwrite(node.getStart(sourceFile), node.getEnd(), replacement);
+      hasReplacements = true;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  if (!hasReplacements) return void 0;
+  s.prepend('import { SolContract as __SolContract } from "soltag";\n');
+  return {
+    code: s.toString(),
+    map: s.generateMap({ source: id, hires: true })
+  };
+}
+var unplugin = createUnplugin((options) => {
+  const include = options?.include ?? [".ts", ".tsx", ".mts", ".cts"];
+  const exclude = options?.exclude ?? [/node_modules/];
+  return {
+    name: "soltag",
+    enforce: "pre",
+    transformInclude(id) {
+      if (exclude.some((e) => e.test(id))) return false;
+      return include.some((ext) => id.endsWith(ext));
+    },
+    transform(code, id) {
+      return transformSolTemplates(code, id);
+    }
+  };
+});
+var unplugin_default = unplugin;
+
+export {
+  transformSolTemplates,
+  unplugin,
+  unplugin_default
+};
+//# sourceMappingURL=chunk-LNEBK5MP.js.map

package/dist/chunk-LNEBK5MP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/build/unplugin.ts","../src/runtime/compiler.ts","../src/solc.ts"],"sourcesContent":["import MagicString from \"magic-string\";\nimport ts from \"typescript\";\nimport { createUnplugin } from \"unplugin\";\n\nimport { compile, hashSource } from \"../runtime/compiler.js\";\n\nexport interface SoltagPluginOptions {\n  /** Extra file extensions to include. Defaults to ['.ts', '.tsx', '.mts', '.cts'] */\n  include?: string[];\n  /** Patterns to exclude. Defaults to [/node_modules/] */\n  exclude?: RegExp[];\n}\n\n/**\n * Try to resolve a TS expression to a string constant at build time.\n * Returns the resolved string, or undefined if the expression can't be statically resolved.\n */\nfunction resolveStringExpression(node: ts.Expression, sourceFile: ts.SourceFile): string | undefined {\n  if (ts.isStringLiteral(node)) return node.text;\n\n  if (ts.isNoSubstitutionTemplateLiteral(node)) return node.text;\n\n  if (ts.isTemplateExpression(node)) {\n    let result = node.head.text;\n    for (const span of node.templateSpans) {\n      const resolved = resolveStringExpression(span.expression, sourceFile);\n      if (resolved === undefined) return undefined;\n      result += resolved + span.literal.text;\n    }\n    return result;\n  }\n\n  if (ts.isIdentifier(node)) {\n    return resolveIdentifierToString(node, sourceFile);\n  }\n\n  // String concatenation with +\n  if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.PlusToken) {\n    const left = resolveStringExpression(node.left, sourceFile);\n    const right = resolveStringExpression(node.right, sourceFile);\n    if (left !== undefined && right !== undefined) return left + right;\n    return undefined;\n  }\n\n  return undefined;\n}\n\n/**\n * Find a const declaration for an identifier and resolve its string value.\n */\nfunction resolveIdentifierToString(identifier: ts.Identifier, sourceFile: ts.SourceFile): string | undefined {\n  const name = identifier.text;\n\n  for (const statement of sourceFile.statements) {\n    if (!ts.isVariableStatement(statement)) continue;\n    if (!(statement.declarationList.flags & ts.NodeFlags.Const)) continue;\n\n    for (const decl of statement.declarationList.declarations) {\n      if (ts.isIdentifier(decl.name) && decl.name.text === name && decl.initializer) {\n        return resolveStringExpression(decl.initializer, sourceFile);\n      }\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Extract the full Solidity source from a tagged template, resolving interpolations.\n * Returns undefined if any interpolation can't be statically resolved.\n */\nfunction extractTemplateSource(template: ts.TemplateLiteral, sourceFile: ts.SourceFile): string | undefined {\n  if (ts.isNoSubstitutionTemplateLiteral(template)) {\n    return template.text;\n  }\n\n  let result = template.head.text;\n  for (const span of template.templateSpans) {\n    const resolved = resolveStringExpression(span.expression, sourceFile);\n    if (resolved === undefined) return undefined;\n    result += resolved + span.literal.text;\n  }\n  return result;\n}\n\n/**\n * Core transform logic, exported for testing.\n */\nexport function transformSolTemplates(\n  code: string,\n  id: string,\n): { code: string; map: ReturnType<MagicString[\"generateMap\"]> } | undefined {\n  if (!code.includes(\"sol`\") && !code.includes(\"sol `\")) return undefined;\n\n  const sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true);\n  const s = new MagicString(code);\n  let hasReplacements = false;\n\n  function visit(node: ts.Node) {\n    if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && node.tag.text === \"sol\") {\n      const soliditySource = extractTemplateSource(node.template, sourceFile);\n      if (soliditySource === undefined) {\n        // Can't resolve at build time — leave for runtime\n        return;\n      }\n\n      const artifacts = compile(soliditySource);\n      const sourceHash = hashSource(soliditySource);\n\n      const replacement = `__SolContract.fromArtifacts(${JSON.stringify(artifacts)}, \"${sourceHash}\")`;\n      s.overwrite(node.getStart(sourceFile), node.getEnd(), replacement);\n      hasReplacements = true;\n      return; // Don't visit children\n    }\n\n    ts.forEachChild(node, visit);\n  }\n\n  visit(sourceFile);\n\n  if (!hasReplacements) return undefined;\n\n  s.prepend('import { SolContract as __SolContract } from \"soltag\";\\n');\n\n  return {\n    code: s.toString(),\n    map: s.generateMap({ source: id, hires: true }),\n  };\n}\n\nexport const unplugin = createUnplugin((options?: SoltagPluginOptions) => {\n  const include = options?.include ?? [\".ts\", \".tsx\", \".mts\", \".cts\"];\n  const exclude = options?.exclude ?? [/node_modules/];\n\n  return {\n    name: \"soltag\",\n    enforce: \"pre\" as const,\n\n    transformInclude(id: string) {\n      if (exclude.some((e) => e.test(id))) return false;\n      return include.some((ext) => id.endsWith(ext));\n    },\n\n    transform(code: string, id: string) {\n      return transformSolTemplates(code, id);\n    },\n  };\n});\n\nexport default unplugin;\n","import { createRequire } from \"node:module\";\n\nimport { type Abi, type Hex, keccak256, toHex } from \"viem\";\n\nimport { buildSolcInput, type SolcError, type SolcModule, type SolcStandardOutput } from \"../solc.js\";\n\nconst require = createRequire(import.meta.url);\n\nlet solcInstance: SolcModule | undefined;\n\nfunction getSolc(): SolcModule {\n  if (!solcInstance) {\n    try {\n      solcInstance = require(\"solc\") as SolcModule;\n    } catch {\n      throw new Error(\n        \"solc is not installed. Install it (`pnpm add solc`) for runtime compilation, \" +\n          \"or use the soltag bundler plugin for build-time compilation.\",\n      );\n    }\n  }\n  return solcInstance;\n}\n\nexport type { SolcAbiItem, SolcAbiParam } from \"../solc.js\";\n\nexport interface CompiledContract {\n  abi: Abi;\n  /** Runtime bytecode (what lives at the contract address). Used with stateOverride. */\n  deployedBytecode: Hex;\n  /** Init bytecode (constructor + deployment code). Used for actual deployment. */\n  initBytecode: Hex;\n}\n\nexport type CompilationResult = Record<string, CompiledContract>;\n\nexport interface SolcDiagnostic {\n  severity: \"error\" | \"warning\";\n  message: string;\n  formattedMessage: string;\n  sourceLocation?: {\n    file: string;\n    start: number;\n    end: number;\n  };\n}\n\nexport class SolCompilationError extends Error {\n  constructor(public readonly errors: SolcDiagnostic[]) {\n    const formatted = errors.map((e) => `${e.severity}: ${e.message}`).join(\"\\n\");\n    super(`Solidity compilation failed:\\n${formatted}`);\n    this.name = \"SolCompilationError\";\n  }\n}\n\n// Cache compiled results by source hash\nconst compilationCache = new Map<string, CompilationResult>();\n\nexport function hashSource(source: string): Hex {\n  return keccak256(toHex(source));\n}\n\nexport function compile(source: string): CompilationResult {\n  const hash = hashSource(source);\n  const cached = compilationCache.get(hash);\n  if (cached) return cached;\n\n  const solc = getSolc();\n  const input = buildSolcInput(source);\n  const rawOutput = solc.compile(JSON.stringify(input));\n  const output = JSON.parse(rawOutput) as SolcStandardOutput;\n\n  const diagnostics = toDiagnostics(output.errors);\n  const errors = diagnostics.filter((d) => d.severity === \"error\");\n  if (errors.length > 0) {\n    throw new SolCompilationError(errors);\n  }\n\n  const result: CompilationResult = {};\n\n  if (output.contracts) {\n    for (const [, fileContracts] of Object.entries(output.contracts)) {\n      for (const [contractName, contractOutput] of Object.entries(fileContracts)) {\n        result[contractName] = {\n          abi: contractOutput.abi as Abi,\n          deployedBytecode: `0x${contractOutput.evm.deployedBytecode.object}` as Hex,\n          initBytecode: `0x${contractOutput.evm.bytecode.object}` as Hex,\n        };\n      }\n    }\n  }\n\n  compilationCache.set(hash, result);\n  return result;\n}\n\nfunction toDiagnostics(errors: SolcError[] | undefined): SolcDiagnostic[] {\n  return (errors ?? []).map((e) => ({\n    severity: e.severity as \"error\" | \"warning\",\n    message: e.message,\n    formattedMessage: e.formattedMessage,\n    sourceLocation: e.sourceLocation,\n  }));\n}\n","/**\n * Shared solc-js types and helpers used by both the runtime compiler\n * and the LS plugin cache.\n */\n\nexport interface SolcModule {\n  compile(input: string): string;\n}\n\n/**\n * Build the standard JSON input object for solc.\n */\nexport function buildSolcInput(source: string) {\n  return {\n    language: \"Solidity\" as const,\n    sources: {\n      \"inline.sol\": { content: source },\n    },\n    settings: {\n      optimizer: { enabled: true, runs: 1 },\n      outputSelection: {\n        \"*\": {\n          \"*\": [\"abi\", \"evm.bytecode.object\", \"evm.deployedBytecode.object\"],\n        },\n      },\n    },\n  };\n}\n\n// --- solc standard output types ---\n\nexport interface SolcStandardOutput {\n  contracts?: Record<string, Record<string, SolcContractOutput>>;\n  errors?: SolcError[];\n}\n\nexport interface SolcContractOutput {\n  abi: SolcAbiItem[];\n  evm: {\n    bytecode: { object: string };\n    deployedBytecode: { object: string };\n  };\n}\n\nexport interface SolcAbiItem {\n  type: string;\n  name?: string;\n  inputs?: SolcAbiParam[];\n  outputs?: SolcAbiParam[];\n  stateMutability?: string;\n}\n\nexport interface SolcAbiParam {\n  name: string;\n  type: string;\n  components?: SolcAbiParam[];\n  internalType?: string;\n}\n\nexport interface SolcError {\n  severity: string;\n  message: string;\n  formattedMessage: string;\n  sourceLocation?: {\n    file: string;\n    start: number;\n    end: number;\n  };\n}\n"],"mappings":"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","names":["require"]}

package/dist/esbuild.d.ts

@@ -0,0 +1,7 @@
+import * as unplugin from 'unplugin';
+import { SoltagPluginOptions } from './unplugin.js';
+import 'magic-string';
+
+declare const _default: (options?: SoltagPluginOptions | undefined) => unplugin.EsbuildPlugin;
+
+export { _default as default };

package/dist/esbuild.js

@@ -0,0 +1,10 @@
+import {
+  unplugin
+} from "./chunk-LNEBK5MP.js";
+
+// src/build/esbuild.ts
+var esbuild_default = unplugin.esbuild;
+export {
+  esbuild_default as default
+};
+//# sourceMappingURL=esbuild.js.map

package/dist/esbuild.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/build/esbuild.ts"],"sourcesContent":["import { unplugin } from \"./unplugin.js\";\nexport default unplugin.esbuild;\n"],"mappings":";;;;;AACA,IAAO,kBAAQ,SAAS;","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,95 @@
+import { Abi, Hex, PublicClient } from 'viem';
+
+interface SolcAbiItem {
+    type: string;
+    name?: string;
+    inputs?: SolcAbiParam[];
+    outputs?: SolcAbiParam[];
+    stateMutability?: string;
+}
+interface SolcAbiParam {
+    name: string;
+    type: string;
+    components?: SolcAbiParam[];
+    internalType?: string;
+}
+
+interface CompiledContract {
+    abi: Abi;
+    /** Runtime bytecode (what lives at the contract address). Used with stateOverride. */
+    deployedBytecode: Hex;
+    /** Init bytecode (constructor + deployment code). Used for actual deployment. */
+    initBytecode: Hex;
+}
+type CompilationResult = Record<string, CompiledContract>;
+interface SolcDiagnostic {
+    severity: "error" | "warning";
+    message: string;
+    formattedMessage: string;
+    sourceLocation?: {
+        file: string;
+        start: number;
+        end: number;
+    };
+}
+declare class SolCompilationError extends Error {
+    readonly errors: SolcDiagnostic[];
+    constructor(errors: SolcDiagnostic[]);
+}
+
+declare class SolContract {
+    private _source;
+    private _compiled;
+    private _address;
+    private _abi;
+    constructor(source: string);
+    /**
+     * Create a SolContract from pre-compiled artifacts.
+     * Used by the bundler plugin to bypass runtime solc compilation.
+     *
+     * @param artifacts - Pre-compiled contract artifacts (ABI + bytecode per contract name)
+     * @param sourceHash - keccak256 of the original Solidity source, for deterministic address derivation
+     */
+    static fromArtifacts(artifacts: CompilationResult, sourceHash?: Hex): SolContract;
+    private ensureCompiled;
+    private getAddress;
+    get abi(): Abi;
+    call(client: PublicClient, functionName: string, args?: readonly unknown[]): Promise<unknown>;
+}
+
+/**
+ * Tagged template literal for inline Solidity.
+ *
+ * Usage:
+ * ```ts
+ * const contract = sol`
+ *   pragma solidity ^0.8.24;
+ *   contract Greeter {
+ *     function greet() external pure returns (string memory) {
+ *       return "hello";
+ *     }
+ *   }
+ * `;
+ * ```
+ *
+ * String interpolation is supported for composing Solidity from reusable fragments:
+ * ```ts
+ * const IERC20 = `
+ *   interface IERC20 {
+ *     function balanceOf(address) external view returns (uint256);
+ *   }
+ * `;
+ *
+ * const contract = sol`
+ *   ${IERC20}
+ *   contract Lens {
+ *     function getBalance(address token, address user) external view returns (uint256) {
+ *       return IERC20(token).balanceOf(user);
+ *     }
+ *   }
+ * `;
+ * ```
+ */
+declare function sol(strings: TemplateStringsArray, ...values: string[]): SolContract;
+
+export { type CompilationResult, type CompiledContract, SolCompilationError, SolContract, type SolcAbiItem, type SolcAbiParam, type SolcDiagnostic, sol };