soltag 0.0.2 → 0.0.3

package/LICENSE

@@ -1,7 +1,5 @@
 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

package/README.md

@@ -1,35 +1,35 @@
 # 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`.
+Inline Solidity in TypeScript. Write Solidity inside a tagged template literal, get a data object with typed `abi`, `bytecode()`, `deployedBytecode`, and a deterministic `address`.
 
 ```ts
 import { sol } from 'soltag';
 
-const contract = sol`
+const lens = sol("Lens")`
   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)
+  contract Lens {
+    function getBalance(address token, address user)
+      external view returns (uint256)
     {
-      out = new uint256[](tokens.length);
-      for (uint256 i = 0; i < tokens.length; i++) {
-        out[i] = IERC20(tokens[i]).balanceOf(user);
-      }
+      return IERC20(token).balanceOf(user);
     }
   }
 `;
 
-const balances = await contract.call(client, 'userBalances', [[USDC, WETH], user]);
-//    ^? bigint[]                        ^? autocompletes    ^? typed args
+lens.name;             // "Lens" (typed as literal)
+lens.abi;              // precise, as-const ABI (via generated .d.ts)
+lens.address;          // `0x${string}` (deterministic, derived from deployedBytecode)
+lens.deployedBytecode; // `0x${string}` (runtime bytecode)
+lens.bytecode();       // `0x${string}` (creation bytecode)
 ```
 
 ## 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)
+- **`sol("Name")` tagged template** — write Solidity inline, get a `InlineContract` with typed ABI, bytecode, and a deterministic address. Supports string interpolation for composing reusable fragments
+- **Real-time IDE support** — inline Solidity diagnostics and contract-name validation via a TypeScript Language Service Plugin. ABI and `bytecode()` types are provided through generated `.d.ts` augmentation
 - **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
+- **Data-oriented** — `InlineContract` is a plain data container. Use `abi` and `bytecode` with whatever execution library you prefer (viem, ethers, etc.)
 
 ## Install
 
@@ -55,14 +55,20 @@ pnpm add -D solc unplugin magic-string
 
 ### Bundler Plugin (recommended for apps)
 
-Compiles `sol` templates at build time — `solc` is only needed during the build, not at runtime.
+Compiles `sol("Name")` 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()],
+  plugins: [
+    soltag({
+      solc: {
+        optimizer: { enabled: true, runs: 200 }
+      }
+    })
+  ],
 });
 ```
 
@@ -76,7 +82,7 @@ import soltag from 'soltag/webpack';
 
 ### TypeScript Plugin (IDE support)
 
-Add to your `tsconfig.json` for autocomplete, hover types, and inline Solidity diagnostics:
+Add to your `tsconfig.json` for inline Solidity diagnostics and contract-name validation:
 
 ```json
 {
@@ -94,12 +100,8 @@ Add to your `tsconfig.json` for autocomplete, hover types, and inline Solidity d
 
 ```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`
+const math = sol("Math")`
   pragma solidity ^0.8.24;
   contract Math {
     function add(uint256 a, uint256 b) external pure returns (uint256) {
@@ -108,30 +110,68 @@ const contract = sol`
   }
 `;
 
-const result = await contract.call(client, 'add', [1n, 2n]);
-// result === 3n
+math.name;             // "Math"
+math.abi;              // readonly [{ type: "function", name: "add", ... }]
+math.bytecode();       // creation bytecode
+math.deployedBytecode; // runtime bytecode
+math.address;          // deterministic address derived from deployedBytecode
 ```
 
-### Reading on-chain state
+### Constructor arguments
+
+For contracts with constructors, `bytecode()` accepts typed arguments:
 
 ```ts
-const contract = sol`
+const token = sol("MyToken")`
   pragma solidity ^0.8.24;
-  interface IERC20 {
-    function balanceOf(address) external view returns (uint256);
-    function decimals() external view returns (uint8);
+  contract MyToken {
+    uint256 public supply;
+    constructor(uint256 _supply) {
+      supply = _supply;
+    }
   }
-  library Lens {
+`;
+
+token.bytecode(1000n); // creation bytecode + ABI-encoded constructor args
+```
+
+### Using with viem
+
+`InlineContract` is a data container — use its properties with any execution library. Here's an example with viem's `eth_call` + `stateOverride` for deployless reads:
+
+```ts
+import { createPublicClient, http, decodeFunctionResult, encodeFunctionData } from 'viem';
+import { mainnet } from 'viem/chains';
+import { sol } from 'soltag';
+
+const client = createPublicClient({ chain: mainnet, transport: http() });
+
+const lens = sol("Lens")`
+  pragma solidity ^0.8.24;
+  interface IERC20 { function balanceOf(address) external view returns (uint256); }
+  contract Lens {
     function getBalance(address token, address user)
-      external view returns (uint256 balance, uint8 decimals)
+      external view returns (uint256)
     {
-      balance = IERC20(token).balanceOf(user);
-      decimals = IERC20(token).decimals();
+      return IERC20(token).balanceOf(user);
     }
   }
 `;
 
-const [balance, decimals] = await contract.call(client, 'getBalance', [USDC, user]);
+const data = encodeFunctionData({
+  abi: lens.abi,
+  functionName: 'getBalance',
+  args: [USDC, user],
+});
+
+const result = await client.call({
+  to: lens.address,
+  data,
+  stateOverrides: [{
+    address: lens.address,
+    code: lens.deployedBytecode,
+  }],
+});
 ```
 
 ### Composing with fragments
@@ -146,7 +186,7 @@ const IERC20 = `
   }
 `;
 
-const balanceLens = sol`
+const balanceLens = sol("BalanceLens")`
   pragma solidity ^0.8.24;
   ${IERC20}
   contract BalanceLens {
@@ -158,18 +198,6 @@ const balanceLens = sol`
     }
   }
 `;
-
-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.
@@ -179,13 +207,13 @@ The bundler plugin resolves `const` string interpolations at build time, so thes
 For environments where you want full control over the compilation step:
 
 ```ts
-import { SolContract } from 'soltag';
+import { InlineContract } from 'soltag';
 
-const contract = SolContract.fromArtifacts({
+const contract = InlineContract.fromArtifacts("MyContract", {
   MyContract: {
     abi: [/* ... */],
     deployedBytecode: '0x...',
-    initBytecode: '0x...',
+    bytecode: '0x...',
   },
 });
 ```
@@ -194,48 +222,66 @@ const contract = SolContract.fromArtifacts({
 
 ### 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
+1. `sol("Name")` captures the Solidity source string and contract name
+2. On first property access, compiles with `solc-js` (lazy-loaded) and caches the result
+3. Exposes `abi`, `bytecode()`, and `deployedBytecode` for the named contract
+4. Derives a deterministic `address` from `keccak256(deployedBytecode)`
 
 ### Build-time path (apps with bundler plugin)
 
-1. The bundler plugin parses each file's AST to find `sol` tagged templates
+1. The bundler plugin parses each file's AST to find `sol("Name")` 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
+4. Replaces `` sol("Name")`...` `` with `InlineContract.fromArtifacts("Name", {...})` containing the pre-compiled ABI and bytecode
+5. At runtime, no compilation happens — property access returns pre-compiled data directly
 
 ### 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
+2. It finds `sol("Name")` tagged templates, compiles them with solc-js, and extracts the ABI
+3. Generates `.soltag/types.d.ts` with module augmentation that narrows `abi` to precise "as const" types and adds typed `bytecode()` overloads per contract
+4. Reports inline Solidity compilation errors and warns if the contract name doesn't match any contract in the source
+
+## Immutables Caveat
+
+Solidity `immutable` variables are assigned in the constructor and baked into the runtime bytecode during deployment. The `deployedBytecode` returned by solc (and exposed by `InlineContract`) contains **placeholder zeros** in immutable slots — the real values are only filled in when the constructor actually runs on-chain.
+
+This means **`deployedBytecode` is unsuitable for `stateOverride` injection** when the contract uses immutable variables. The zeroed slots will cause the contract to behave incorrectly.
+
+If your contract uses immutables, deploy it normally using `bytecode(…constructorArgs)` instead of injecting `deployedBytecode` via `stateOverride`. Note that `bytecode()` returns _creation_ bytecode (the code that runs the constructor and returns the final runtime code), not runtime bytecode with constructor args spliced in — there is no way to produce correct runtime bytecode with immutables without actually executing the constructor.
 
 ## API
 
 ### `sol`
 
 ```ts
-function sol(strings: TemplateStringsArray, ...values: string[]): SolContract;
+function sol<TName extends string>(name: TName):
+  (strings: TemplateStringsArray, ...values: string[]) => InlineContract<TName>;
 ```
 
-Tagged template literal. Accepts string interpolations for composing Solidity from reusable fragments.
+Factory that returns a tagged template function. The `name` must match a contract in the Solidity source.
 
-### `SolContract`
+### `InlineContract<TName>`
 
 ```ts
-class SolContract {
+class InlineContract<TName extends string = string> {
   // Create from pre-compiled artifacts (used by bundler plugin)
-  static fromArtifacts(artifacts: CompilationResult, sourceHash?: Hex): SolContract;
+  static fromArtifacts<T extends string>(name: T, artifacts: CompilationResult): InlineContract<T>;
+
+  // The contract name (typed as a string literal)
+  get name(): TName;
+
+  // The contract's ABI (narrowed to precise type via generated .d.ts)
+  get abi(): Abi;
+
+  // Runtime bytecode as emitted by solc (see Immutables Caveat)
+  get deployedBytecode(): Hex;
 
-  // Merged ABI across all contracts in the source
-  readonly abi: Abi;
+  // Deterministic address derived from keccak256(deployedBytecode)
+  get address(): Hex;
 
-  // Execute a read-only call via stateOverride
-  call(client: PublicClient, functionName: string, args?: readonly unknown[]): Promise<unknown>;
+  // Creation bytecode, optionally with ABI-encoded constructor args appended
+  bytecode(...args: unknown[]): Hex;
 }
 ```
 

package/dist/chunk-YTNI7QSL.js

@@ -0,0 +1,351 @@
+// src/bundler/unplugin.ts
+import * as fs from "fs";
+import * as path from "path";
+import MagicString from "magic-string";
+import ts from "typescript";
+import { createUnplugin } from "unplugin";
+
+// src/ast-utils.ts
+function isSolTag(ts2, tag) {
+  if (ts2.isCallExpression(tag) && ts2.isIdentifier(tag.expression) && tag.expression.text === "sol" && tag.arguments.length === 1 && ts2.isStringLiteral(tag.arguments[0])) {
+    return { contractName: tag.arguments[0].text };
+  }
+  return false;
+}
+function resolveStringExpression(ts2, node, sourceFile) {
+  if (ts2.isStringLiteral(node)) return node.text;
+  if (ts2.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  if (ts2.isTemplateExpression(node)) {
+    let result = node.head.text;
+    for (const span of node.templateSpans) {
+      const resolved = resolveStringExpression(ts2, span.expression, sourceFile);
+      if (resolved === void 0) return void 0;
+      result += resolved + span.literal.text;
+    }
+    return result;
+  }
+  if (ts2.isIdentifier(node)) {
+    return resolveIdentifierToString(ts2, node, sourceFile);
+  }
+  if (ts2.isBinaryExpression(node) && node.operatorToken.kind === ts2.SyntaxKind.PlusToken) {
+    const left = resolveStringExpression(ts2, node.left, sourceFile);
+    const right = resolveStringExpression(ts2, node.right, sourceFile);
+    if (left !== void 0 && right !== void 0) return left + right;
+    return void 0;
+  }
+  return void 0;
+}
+function resolveIdentifierToString(ts2, identifier, sourceFile) {
+  const name = identifier.text;
+  for (const statement of sourceFile.statements) {
+    if (!ts2.isVariableStatement(statement)) continue;
+    if (!(statement.declarationList.flags & ts2.NodeFlags.Const)) continue;
+    for (const decl of statement.declarationList.declarations) {
+      if (ts2.isIdentifier(decl.name) && decl.name.text === name && decl.initializer) {
+        return resolveStringExpression(ts2, decl.initializer, sourceFile);
+      }
+    }
+  }
+  return void 0;
+}
+function extractTemplateSource(ts2, template, sourceFile) {
+  if (ts2.isNoSubstitutionTemplateLiteral(template)) {
+    return template.text;
+  }
+  let result = template.head.text;
+  for (const span of template.templateSpans) {
+    const resolved = resolveStringExpression(ts2, span.expression, sourceFile);
+    if (resolved === void 0) return void 0;
+    result += resolved + span.literal.text;
+  }
+  return result;
+}
+
+// src/codegen.ts
+var SOLTAG_DIR = ".soltag";
+var SOLTAG_TYPES_FILE = "types.d.ts";
+function solidityTypeToTs(param) {
+  const t = param.type;
+  if (t === "address") return "`0x${string}`";
+  if (t === "bool") return "boolean";
+  if (t === "string") return "string";
+  if (t === "bytes" || t.match(/^bytes\d+$/)) return "`0x${string}`";
+  if (t.match(/^u?int\d*$/)) return "bigint";
+  if (t.endsWith("[]")) {
+    const inner = { ...param, type: t.slice(0, -2) };
+    return `${solidityTypeToTs(inner)}[]`;
+  }
+  const fixedArray = t.match(/^(.+)\[(\d+)\]$/);
+  if (fixedArray) {
+    const inner = { ...param, type: fixedArray[1] };
+    return `${solidityTypeToTs(inner)}[]`;
+  }
+  if (t === "tuple" && param.components) {
+    const fields = param.components.map((c) => `${c.name}: ${solidityTypeToTs(c)}`).join("; ");
+    return `{ ${fields} }`;
+  }
+  return "unknown";
+}
+function jsonToConstType(value) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number") return String(value);
+  if (typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "readonly []";
+    return `readonly [${value.map(jsonToConstType).join(", ")}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) return "{}";
+    const fields = entries.map(([k, v]) => `readonly ${k}: ${jsonToConstType(v)}`);
+    return `{ ${fields.join("; ")} }`;
+  }
+  return "unknown";
+}
+function generateDeclarationContent(entries) {
+  if (entries.length === 0) return { content: "", duplicates: [] };
+  const byName = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const existing = byName.get(entry.contractName);
+    if (existing) {
+      existing.push(entry);
+    } else {
+      byName.set(entry.contractName, [entry]);
+    }
+  }
+  const duplicates = [];
+  const unique = [];
+  for (const [name, group] of byName) {
+    unique.push(group[0]);
+    if (group.length > 1) {
+      const fingerprints = new Set(
+        group.map((e) => JSON.stringify({ constructorInputs: e.constructorInputs, abi: e.abi }))
+      );
+      if (fingerprints.size > 1) {
+        duplicates.push(name);
+      }
+    }
+  }
+  const abiMapEntries = [];
+  const overloads = [];
+  for (const entry of unique) {
+    abiMapEntries.push(`      ${JSON.stringify(entry.contractName)}: ${jsonToConstType(entry.abi)};`);
+    const params = entry.constructorInputs.map((p, i) => {
+      const name = p.name || `arg${i}`;
+      return `${name}: ${solidityTypeToTs(p)}`;
+    });
+    overloads.push(
+      `      bytecode(this: InlineContract<${JSON.stringify(entry.contractName)}>${params.length > 0 ? `, ${params.join(", ")}` : ""}): \`0x\${string}\`;`
+    );
+  }
+  if (unique.length === 0) return { content: "", duplicates };
+  const content = `export {}
+declare module "soltag" {
+  interface InlineContractAbiMap {
+${abiMapEntries.join("\n")}
+  }
+  interface InlineContract<TName extends string> {
+${overloads.join("\n")}
+  }
+}
+`;
+  return { content, duplicates };
+}
+
+// src/runtime/compiler.ts
+import { createRequire } from "module";
+import { keccak256, toHex } from "viem";
+
+// src/solc.ts
+function buildSolcInput(source, options) {
+  return {
+    language: "Solidity",
+    sources: {
+      "inline.sol": { content: source }
+    },
+    settings: {
+      optimizer: {
+        enabled: options?.optimizer?.enabled ?? true,
+        runs: options?.optimizer?.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, options) {
+  return keccak256(toHex(source + JSON.stringify(options ?? {})));
+}
+function compile(source, options) {
+  const hash = hashSource(source, options);
+  const cached = compilationCache.get(hash);
+  if (cached) return cached;
+  const solc = getSolc();
+  const input = buildSolcInput(source, options);
+  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}`,
+          bytecode: `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/bundler/unplugin.ts
+function getConstructorInputs(abi) {
+  const ctor = abi.find((item) => item.type === "constructor");
+  if (!ctor) return [];
+  return ctor.inputs ?? [];
+}
+function transformSolTemplates(code, id, namedEntries, options) {
+  if (!/\bsol\s*\(\s*["'][^"']+["']\s*\)/.test(code)) 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)) {
+      const solTag = isSolTag(ts, node.tag);
+      if (solTag) {
+        const contractName = solTag.contractName;
+        const soliditySource = extractTemplateSource(ts, node.template, sourceFile);
+        if (soliditySource === void 0) {
+          return;
+        }
+        const artifacts = compile(soliditySource, options?.solc);
+        if (namedEntries != null) {
+          const contractArtifact = artifacts[contractName];
+          const constructorInputs = contractArtifact ? getConstructorInputs(contractArtifact.abi) : [];
+          const abi = contractArtifact ? contractArtifact.abi : [];
+          namedEntries.set(`${contractName}\0${soliditySource}`, {
+            contractName,
+            constructorInputs,
+            abi
+          });
+        }
+        const replacement = `__InlineContract.fromArtifacts(${JSON.stringify(contractName)}, ${JSON.stringify(artifacts)})`;
+        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 { InlineContract as __InlineContract } 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/];
+  const namedEntries = /* @__PURE__ */ new Map();
+  let rootDir;
+  return {
+    name: "soltag",
+    enforce: "pre",
+    vite: {
+      configResolved(config) {
+        rootDir = config.root;
+      }
+    },
+    buildStart() {
+      namedEntries.clear();
+    },
+    transform: {
+      filter: {
+        id: {
+          include: include.map((ext) => new RegExp(`${ext.replace(".", "\\.")}$`)),
+          exclude
+        }
+      },
+      handler(code, id) {
+        if (!rootDir) {
+          rootDir = process.cwd();
+        }
+        return transformSolTemplates(code, id, namedEntries, options);
+      }
+    },
+    buildEnd() {
+      if (!rootDir || namedEntries.size === 0) return;
+      const entries = Array.from(namedEntries.values());
+      const { content } = generateDeclarationContent(entries);
+      if (content === "") return;
+      const typesDir = path.join(rootDir, SOLTAG_DIR);
+      const typesFile = path.join(typesDir, SOLTAG_TYPES_FILE);
+      if (!fs.existsSync(typesDir)) {
+        fs.mkdirSync(typesDir, { recursive: true });
+      }
+      let existing;
+      try {
+        existing = fs.readFileSync(typesFile, "utf-8");
+      } catch {
+      }
+      if (existing !== content) {
+        fs.writeFileSync(typesFile, content, "utf-8");
+      }
+    }
+  };
+});
+var unplugin_default = unplugin;
+
+export {
+  transformSolTemplates,
+  unplugin,
+  unplugin_default
+};
+//# sourceMappingURL=chunk-YTNI7QSL.js.map