@codama/renderers-js 1.7.0 → 2.0.1

package/dist/index.react-native.mjs

@@ -1,7 +1,7 @@
 import { camelCase, pascalCase, snakeCase, titleCase, kebabCase, capitalize, REGISTERED_TYPE_NODE_KINDS, REGISTERED_VALUE_NODE_KINDS, isNodeFilter, resolveNestedTypeNode, structTypeNodeFromInstructionArgumentNodes, isNode, isScalarEnum, structTypeNode, structFieldTypeNode, getAllPrograms, getAllPdas, getAllAccounts, getAllInstructionsWithSubs, getAllDefinedTypes, definedTypeLinkNode, definedTypeNode, isDataEnum, accountValueNode, argumentValueNode, parseOptionalAccountStrategy, VALUE_NODES, getAllInstructionArguments, constantDiscriminatorNode, constantValueNodeFromBytes, constantValueNode, assertIsNode } from '@codama/nodes';
-import { setFragmentContent, mapFragmentContent, createRenderMap, mergeRenderMaps, deleteDirectory, mapRenderMapContentAsync, writeRenderMap, createFragmentTemplate, joinPath, fileExists, readJson, writeFile } from '@codama/renderers-core';
 import { NodeStack, pipe, staticVisitor, extendVisitor, visit, findLastNodeFromPath, recordNodeStackVisitor, LinkableDictionary, getResolvedInstructionInputsVisitor, getByteSizeVisitor, recordLinkablesOnFirstVisitVisitor, rootNodeVisitor, findProgramNodeFromPath, getLastNodeFromPath, findInstructionNodeFromPath, deduplicateInstructionDependencies } from '@codama/visitors-core';
 import { getBase64Encoder, getBase58Encoder, getBase16Encoder, getUtf8Encoder, getBase64Decoder } from '@solana/codecs-strings';
+import { setFragmentContent, mapFragmentContent, createRenderMap, mergeRenderMaps, joinPath, deleteDirectory, mapRenderMapContentAsync, writeRenderMap, createFragmentTemplate, fileExists, readJson, writeFile } from '@codama/renderers-core';
 import 'prettier';
 import * as babelPlugin from 'prettier/plugins/babel';
 import * as estreePlugin from 'prettier/plugins/estree';
@@ -10,270 +10,7 @@ import { format } from 'prettier/standalone';
 import { CodamaError, CODAMA_ERROR__UNEXPECTED_NODE_KIND, logWarn, CODAMA_ERROR__RENDERERS__MISSING_DEPENDENCY_VERSIONS } from '@codama/errors';
 import { subset, minVersion, lt } from 'semver';
 
-// src/utils/importMap.ts
-var DEFAULT_EXTERNAL_MODULE_MAP = {
-  solanaAccounts: "@solana/kit",
-  solanaAddresses: "@solana/kit",
-  solanaCodecsCore: "@solana/kit",
-  solanaCodecsDataStructures: "@solana/kit",
-  solanaCodecsNumbers: "@solana/kit",
-  solanaCodecsStrings: "@solana/kit",
-  solanaErrors: "@solana/kit",
-  solanaInstructions: "@solana/kit",
-  solanaOptions: "@solana/kit",
-  solanaPrograms: "@solana/kit",
-  solanaRpcTypes: "@solana/kit",
-  solanaSigners: "@solana/kit"
-};
-var DEFAULT_GRANULAR_EXTERNAL_MODULE_MAP = {
-  solanaAccounts: "@solana/accounts",
-  solanaAddresses: "@solana/addresses",
-  solanaCodecsCore: "@solana/codecs",
-  solanaCodecsDataStructures: "@solana/codecs",
-  solanaCodecsNumbers: "@solana/codecs",
-  solanaCodecsStrings: "@solana/codecs",
-  solanaErrors: "@solana/errors",
-  solanaInstructions: "@solana/instructions",
-  solanaOptions: "@solana/codecs",
-  solanaPrograms: "@solana/programs",
-  solanaRpcTypes: "@solana/rpc-types",
-  solanaSigners: "@solana/signers"
-};
-var DEFAULT_INTERNAL_MODULE_MAP = {
-  errors: "../errors",
-  generated: "..",
-  generatedAccounts: "../accounts",
-  generatedErrors: "../errors",
-  generatedInstructions: "../instructions",
-  generatedPdas: "../pdas",
-  generatedPrograms: "../programs",
-  generatedTypes: "../types",
-  hooked: "../../hooked",
-  shared: "../shared",
-  types: "../types"
-};
-function createImportMap() {
-  return Object.freeze(/* @__PURE__ */ new Map());
-}
-function parseImportInput(input) {
-  const matches = input.match(/^(type )?([^ ]+)(?: as (.+))?$/);
-  if (!matches) return Object.freeze({ importedIdentifier: input, isType: false, usedIdentifier: input });
-  const [_, isType, name, alias] = matches;
-  return Object.freeze({
-    importedIdentifier: name,
-    isType: !!isType,
-    usedIdentifier: alias ?? name
-  });
-}
-function addToImportMap(importMap, module, imports) {
-  const parsedImports = imports.map(parseImportInput).map((i) => [i.usedIdentifier, i]);
-  return mergeImportMaps([importMap, /* @__PURE__ */ new Map([[module, new Map(parsedImports)]])]);
-}
-function removeFromImportMap(importMap, module, usedIdentifiers) {
-  const newMap = new Map(importMap);
-  const newModuleMap = new Map(newMap.get(module));
-  usedIdentifiers.forEach((usedIdentifier) => {
-    newModuleMap.delete(usedIdentifier);
-  });
-  if (newModuleMap.size === 0) {
-    newMap.delete(module);
-  } else {
-    newMap.set(module, newModuleMap);
-  }
-  return Object.freeze(newMap);
-}
-function mergeImportMaps(importMaps) {
-  if (importMaps.length === 0) return createImportMap();
-  if (importMaps.length === 1) return importMaps[0];
-  const mergedMap = new Map(importMaps[0]);
-  for (const map of importMaps.slice(1)) {
-    for (const [module, imports] of map) {
-      const mergedModuleMap = mergedMap.get(module) ?? /* @__PURE__ */ new Map();
-      for (const [usedIdentifier, importInfo] of imports) {
-        const existingImportInfo = mergedModuleMap.get(usedIdentifier);
-        const shouldOverwriteTypeOnly = existingImportInfo && existingImportInfo.importedIdentifier === importInfo.importedIdentifier && existingImportInfo.isType && !importInfo.isType;
-        if (!existingImportInfo || shouldOverwriteTypeOnly) {
-          mergedModuleMap.set(usedIdentifier, importInfo);
-        }
-      }
-      mergedMap.set(module, mergedModuleMap);
-    }
-  }
-  return Object.freeze(mergedMap);
-}
-function importMapToString(importMap, dependencyMap = {}, useGranularImports = false) {
-  const resolvedMap = resolveImportMapModules(importMap, dependencyMap, useGranularImports);
-  return [...resolvedMap.entries()].sort(([a], [b]) => {
-    const relative = Number(a.startsWith(".")) - Number(b.startsWith("."));
-    if (relative !== 0) return relative;
-    return a.localeCompare(b);
-  }).map(([module, imports]) => {
-    const innerImports = [...imports.values()].map(importInfoToString).sort((a, b) => a.localeCompare(b)).join(", ");
-    return `import { ${innerImports} } from '${module}';`;
-  }).join("\n");
-}
-function getExternalDependencies(importMap, dependencyMap, useGranularImports) {
-  const resolvedImports = resolveImportMapModules(importMap, dependencyMap, useGranularImports);
-  return new Set([...resolvedImports.keys()].filter((module) => !module.startsWith(".")));
-}
-function resolveImportMapModules(importMap, dependencyMap, useGranularImports) {
-  const dependencyMapWithDefaults = {
-    ...useGranularImports ? DEFAULT_GRANULAR_EXTERNAL_MODULE_MAP : DEFAULT_EXTERNAL_MODULE_MAP,
-    ...DEFAULT_INTERNAL_MODULE_MAP,
-    ...dependencyMap
-  };
-  return mergeImportMaps(
-    [...importMap.entries()].map(([module, imports]) => {
-      const resolvedModule = dependencyMapWithDefaults[module] ?? module;
-      return /* @__PURE__ */ new Map([[resolvedModule, imports]]);
-    })
-  );
-}
-function importInfoToString({ importedIdentifier, isType, usedIdentifier }) {
-  const alias = importedIdentifier !== usedIdentifier ? ` as ${usedIdentifier}` : "";
-  return `${isType ? "type " : ""}${importedIdentifier}${alias}`;
-}
-function getNameApi(transformers) {
-  const helpers = {
-    camelCase,
-    capitalize,
-    kebabCase,
-    pascalCase,
-    snakeCase,
-    titleCase
-  };
-  return Object.fromEntries(
-    Object.entries(transformers).map(([key, transformer]) => [key, (name) => transformer(name, helpers)])
-  );
-}
-var DEFAULT_NAME_TRANSFORMERS = {
-  accountDecodeFunction: (name) => `decode${pascalCase(name)}`,
-  accountFetchAllFunction: (name) => `fetchAll${pascalCase(name)}`,
-  accountFetchAllMaybeFunction: (name) => `fetchAllMaybe${pascalCase(name)}`,
-  accountFetchFromSeedsFunction: (name) => `fetch${pascalCase(name)}FromSeeds`,
-  accountFetchFunction: (name) => `fetch${pascalCase(name)}`,
-  accountFetchMaybeFromSeedsFunction: (name) => `fetchMaybe${pascalCase(name)}FromSeeds`,
-  accountFetchMaybeFunction: (name) => `fetchMaybe${pascalCase(name)}`,
-  accountGetSizeFunction: (name) => `get${pascalCase(name)}Size`,
-  codecFunction: (name) => `get${pascalCase(name)}Codec`,
-  constant: (name) => snakeCase(name).toUpperCase(),
-  constantFunction: (name) => `get${pascalCase(name)}Bytes`,
-  dataArgsType: (name) => `${pascalCase(name)}Args`,
-  dataType: (name) => `${pascalCase(name)}`,
-  decoderFunction: (name) => `get${pascalCase(name)}Decoder`,
-  discriminatedUnionDiscriminator: () => "__kind",
-  discriminatedUnionFunction: (name) => `${camelCase(name)}`,
-  discriminatedUnionVariant: (name) => `${pascalCase(name)}`,
-  encoderFunction: (name) => `get${pascalCase(name)}Encoder`,
-  enumVariant: (name) => `${pascalCase(name)}`,
-  instructionAsyncFunction: (name) => `get${pascalCase(name)}InstructionAsync`,
-  instructionAsyncInputType: (name) => `${pascalCase(name)}AsyncInput`,
-  instructionDataType: (name) => `${pascalCase(name)}InstructionData`,
-  instructionExtraType: (name) => `${pascalCase(name)}InstructionExtra`,
-  instructionParseFunction: (name) => `parse${pascalCase(name)}Instruction`,
-  instructionParsedType: (name) => `Parsed${pascalCase(name)}Instruction`,
-  instructionSyncFunction: (name) => `get${pascalCase(name)}Instruction`,
-  instructionSyncInputType: (name) => `${pascalCase(name)}Input`,
-  instructionType: (name) => `${pascalCase(name)}Instruction`,
-  isDiscriminatedUnionFunction: (name) => `is${pascalCase(name)}`,
-  pdaFindFunction: (name) => `find${pascalCase(name)}Pda`,
-  pdaSeedsType: (name) => `${pascalCase(name)}Seeds`,
-  programAccountsEnum: (name) => `${pascalCase(name)}Account`,
-  programAccountsEnumVariant: (name) => `${pascalCase(name)}`,
-  programAccountsIdentifierFunction: (name) => `identify${pascalCase(name)}Account`,
-  programAddressConstant: (name) => `${snakeCase(name).toUpperCase()}_PROGRAM_ADDRESS`,
-  programErrorConstant: (name) => snakeCase(name).toUpperCase(),
-  programErrorConstantPrefix: (name) => `${snakeCase(name).toUpperCase()}_ERROR__`,
-  programErrorMessagesMap: (name) => `${camelCase(name)}ErrorMessages`,
-  programErrorUnion: (name) => `${pascalCase(name)}Error`,
-  programGetErrorMessageFunction: (name) => `get${pascalCase(name)}ErrorMessage`,
-  programInstructionsEnum: (name) => `${pascalCase(name)}Instruction`,
-  programInstructionsEnumVariant: (name) => `${pascalCase(name)}`,
-  programInstructionsIdentifierFunction: (name) => `identify${pascalCase(name)}Instruction`,
-  programInstructionsParseFunction: (name) => `parse${pascalCase(name)}Instruction`,
-  programInstructionsParsedUnionType: (name) => `Parsed${pascalCase(name)}Instruction`,
-  programIsErrorFunction: (name) => `is${pascalCase(name)}Error`,
-  resolverFunction: (name) => `${camelCase(name)}`
-};
-function createFragment(content) {
-  return Object.freeze({ content, features: /* @__PURE__ */ new Set(), imports: createImportMap() });
-}
-function isFragment(value) {
-  return typeof value === "object" && value !== null && "content" in value;
-}
-function fragment(template, ...items) {
-  return createFragmentTemplate(template, items, isFragment, mergeFragments);
-}
-function mergeFragments(fragments, mergeContent) {
-  const filteredFragments = fragments.filter((f) => f !== void 0);
-  return Object.freeze({
-    content: mergeContent(filteredFragments.map((fragment2) => fragment2.content)),
-    features: new Set(filteredFragments.flatMap((f) => [...f.features])),
-    imports: mergeImportMaps(filteredFragments.map((f) => f.imports))
-  });
-}
-function use(importInput, module) {
-  const importInfo = parseImportInput(importInput);
-  return addFragmentImports(createFragment(importInfo.usedIdentifier), module, [importInput]);
-}
-function mergeFragmentImports(fragment2, importMaps) {
-  return Object.freeze({ ...fragment2, imports: mergeImportMaps([fragment2.imports, ...importMaps]) });
-}
-function addFragmentImports(fragment2, module, importInputs) {
-  return Object.freeze({ ...fragment2, imports: addToImportMap(fragment2.imports, module, importInputs) });
-}
-function removeFragmentImports(fragment2, module, usedIdentifiers) {
-  return Object.freeze({ ...fragment2, imports: removeFromImportMap(fragment2.imports, module, usedIdentifiers) });
-}
-function addFragmentFeatures(fragment2, features) {
-  return Object.freeze({ ...fragment2, features: /* @__PURE__ */ new Set([...fragment2.features, ...features]) });
-}
-function getExportAllFragment(module) {
-  return fragment`export * from '${module}';`;
-}
-function getDocblockFragment(lines, withLineJump = false) {
-  const lineJump = withLineJump ? "\n" : "";
-  if (lines.length === 0) return;
-  if (lines.length === 1) return fragment`/** ${lines[0]} */${lineJump}`;
-  const prefixedLines = lines.map((line) => line ? ` * ${line}` : " *");
-  return fragment`/**\n${prefixedLines.join("\n")}\n */${lineJump}`;
-}
-function getPageFragment(page, scope) {
-  const header = getDocblockFragment([
-    "This code was AUTOGENERATED using the Codama library.",
-    "Please DO NOT EDIT THIS FILE, instead use visitors",
-    "to add features, then rerun Codama to update it.",
-    "",
-    "@see https://github.com/codama-idl/codama"
-  ]);
-  const imports = page.imports.size === 0 ? void 0 : fragment`${importMapToString(page.imports, scope.dependencyMap, scope.useGranularImports)}`;
-  return mergeFragments([header, imports, page], (cs) => cs.join("\n\n"));
-}
-
-// src/utils/typeManifest.ts
-function typeManifest(input = {}) {
-  return Object.freeze({
-    decoder: fragment``,
-    encoder: fragment``,
-    isEnum: false,
-    looseType: fragment``,
-    strictType: fragment``,
-    value: fragment``,
-    ...input
-  });
-}
-function mergeTypeManifests(manifests, options = {}) {
-  const { mergeTypes, mergeCodecs, mergeValues } = options;
-  const merge = (fragmentFn, mergeFn) => mergeFn ? mergeFragments(manifests.map(fragmentFn), mergeFn) : fragment``;
-  return Object.freeze({
-    decoder: merge((m) => m.decoder, mergeCodecs),
-    encoder: merge((m) => m.encoder, mergeCodecs),
-    isEnum: false,
-    looseType: merge((m) => m.looseType, mergeTypes),
-    strictType: merge((m) => m.strictType, mergeTypes),
-    value: merge((m) => m.value, mergeValues)
-  });
-}
+// src/utils/async.ts
 function hasAsyncFunction(instructionNode, resolvedInputs, asyncResolvers) {
   const hasByteDeltasAsync = (instructionNode.byteDeltas ?? []).some(
     ({ value }) => isNode(value, "resolverValueNode") && asyncResolvers.includes(value.name)
@@ -389,12 +126,12 @@ var getDefinedTypeNodesToExtract = (nodes, parsedCustomDataOptions) => nodes.fla
 var DEFAULT_PRETTIER_OPTIONS = {
   plugins: [estreePlugin, typeScriptPlugin, babelPlugin]
 };
-async function getCodeFormatter(options) {
+async function getCodeFormatter(packageFolder, options) {
   const shouldFormatCode = options.formatCode ?? true;
   if (!shouldFormatCode) return (code) => Promise.resolve(code);
   const prettierOptions = {
     ...DEFAULT_PRETTIER_OPTIONS,
-    ...await resolvePrettierOptions(options.packageFolder),
+    ...await resolvePrettierOptions(),
     ...options.prettierOptions
   };
   return (code, filepath) => format(code, { ...prettierOptions, filepath });
@@ -404,6 +141,60 @@ async function resolvePrettierOptions(packageFolder) {
     return null;
   }
 }
+function createFragment(content) {
+  return Object.freeze({ content, features: /* @__PURE__ */ new Set(), imports: createImportMap() });
+}
+function isFragment(value) {
+  return typeof value === "object" && value !== null && "content" in value;
+}
+function fragment(template, ...items) {
+  return createFragmentTemplate(template, items, isFragment, mergeFragments);
+}
+function mergeFragments(fragments, mergeContent) {
+  const filteredFragments = fragments.filter((f) => f !== void 0);
+  return Object.freeze({
+    content: mergeContent(filteredFragments.map((fragment2) => fragment2.content)),
+    features: new Set(filteredFragments.flatMap((f) => [...f.features])),
+    imports: mergeImportMaps(filteredFragments.map((f) => f.imports))
+  });
+}
+function use(importInput, module) {
+  const importInfo = parseImportInput(importInput);
+  return addFragmentImports(createFragment(importInfo.usedIdentifier), module, [importInput]);
+}
+function mergeFragmentImports(fragment2, importMaps) {
+  return Object.freeze({ ...fragment2, imports: mergeImportMaps([fragment2.imports, ...importMaps]) });
+}
+function addFragmentImports(fragment2, module, importInputs) {
+  return Object.freeze({ ...fragment2, imports: addToImportMap(fragment2.imports, module, importInputs) });
+}
+function removeFragmentImports(fragment2, module, usedIdentifiers) {
+  return Object.freeze({ ...fragment2, imports: removeFromImportMap(fragment2.imports, module, usedIdentifiers) });
+}
+function addFragmentFeatures(fragment2, features) {
+  return Object.freeze({ ...fragment2, features: /* @__PURE__ */ new Set([...fragment2.features, ...features]) });
+}
+function getExportAllFragment(module) {
+  return fragment`export * from '${module}';`;
+}
+function getDocblockFragment(lines, withLineJump = false) {
+  const lineJump = withLineJump ? "\n" : "";
+  if (lines.length === 0) return;
+  if (lines.length === 1) return fragment`/** ${lines[0]} */${lineJump}`;
+  const prefixedLines = lines.map((line) => line ? ` * ${line}` : " *");
+  return fragment`/**\n${prefixedLines.join("\n")}\n */${lineJump}`;
+}
+function getPageFragment(page, scope) {
+  const header = getDocblockFragment([
+    "This code was AUTOGENERATED using the Codama library.",
+    "Please DO NOT EDIT THIS FILE, instead use visitors",
+    "to add features, then rerun Codama to update it.",
+    "",
+    "@see https://github.com/codama-idl/codama"
+  ]);
+  const imports = page.imports.size === 0 ? void 0 : fragment`${importMapToString(page.imports, scope.dependencyMap, scope.kitImportStrategy)}`;
+  return mergeFragments([header, imports, page], (cs) => cs.join("\n\n"));
+}
 function getImportFromFactory(overrides, customAccountData, customInstructionData) {
   const customDataOverrides = Object.fromEntries(
     [...customAccountData.values(), ...customInstructionData.values()].map(({ importFrom, importAs }) => [
@@ -450,6 +241,79 @@ function getImportFromFactory(overrides, customAccountData, customInstructionDat
     }
   };
 }
+function getNameApi(transformers) {
+  const helpers = {
+    camelCase: camelCase,
+    capitalize,
+    kebabCase,
+    pascalCase,
+    snakeCase,
+    titleCase
+  };
+  return Object.fromEntries(
+    Object.entries(transformers).map(([key, transformer]) => [key, (name) => transformer(name, helpers)])
+  );
+}
+var DEFAULT_NAME_TRANSFORMERS = {
+  accountDecodeFunction: (name) => `decode${pascalCase(name)}`,
+  accountFetchAllFunction: (name) => `fetchAll${pascalCase(name)}`,
+  accountFetchAllMaybeFunction: (name) => `fetchAllMaybe${pascalCase(name)}`,
+  accountFetchFromSeedsFunction: (name) => `fetch${pascalCase(name)}FromSeeds`,
+  accountFetchFunction: (name) => `fetch${pascalCase(name)}`,
+  accountFetchMaybeFromSeedsFunction: (name) => `fetchMaybe${pascalCase(name)}FromSeeds`,
+  accountFetchMaybeFunction: (name) => `fetchMaybe${pascalCase(name)}`,
+  accountGetSizeFunction: (name) => `get${pascalCase(name)}Size`,
+  codecFunction: (name) => `get${pascalCase(name)}Codec`,
+  constant: (name) => snakeCase(name).toUpperCase(),
+  constantFunction: (name) => `get${pascalCase(name)}Bytes`,
+  dataArgsType: (name) => `${pascalCase(name)}Args`,
+  dataType: (name) => `${pascalCase(name)}`,
+  decoderFunction: (name) => `get${pascalCase(name)}Decoder`,
+  discriminatedUnionDiscriminator: () => "__kind",
+  discriminatedUnionFunction: (name) => `${camelCase(name)}`,
+  discriminatedUnionVariant: (name) => `${pascalCase(name)}`,
+  encoderFunction: (name) => `get${pascalCase(name)}Encoder`,
+  enumVariant: (name) => `${pascalCase(name)}`,
+  instructionAsyncFunction: (name) => `get${pascalCase(name)}InstructionAsync`,
+  instructionAsyncInputType: (name) => `${pascalCase(name)}AsyncInput`,
+  instructionDataType: (name) => `${pascalCase(name)}InstructionData`,
+  instructionExtraType: (name) => `${pascalCase(name)}InstructionExtra`,
+  instructionParseFunction: (name) => `parse${pascalCase(name)}Instruction`,
+  instructionParsedType: (name) => `Parsed${pascalCase(name)}Instruction`,
+  instructionSyncFunction: (name) => `get${pascalCase(name)}Instruction`,
+  instructionSyncInputType: (name) => `${pascalCase(name)}Input`,
+  instructionType: (name) => `${pascalCase(name)}Instruction`,
+  isDiscriminatedUnionFunction: (name) => `is${pascalCase(name)}`,
+  pdaFindFunction: (name) => `find${pascalCase(name)}Pda`,
+  pdaSeedsType: (name) => `${pascalCase(name)}Seeds`,
+  programAccountsEnum: (name) => `${pascalCase(name)}Account`,
+  programAccountsEnumVariant: (name) => `${pascalCase(name)}`,
+  programAccountsIdentifierFunction: (name) => `identify${pascalCase(name)}Account`,
+  programAddressConstant: (name) => `${snakeCase(name).toUpperCase()}_PROGRAM_ADDRESS`,
+  programErrorConstant: (name) => snakeCase(name).toUpperCase(),
+  programErrorConstantPrefix: (name) => `${snakeCase(name).toUpperCase()}_ERROR__`,
+  programErrorMessagesMap: (name) => `${camelCase(name)}ErrorMessages`,
+  programErrorUnion: (name) => `${pascalCase(name)}Error`,
+  programGetErrorMessageFunction: (name) => `get${pascalCase(name)}ErrorMessage`,
+  programInstructionsEnum: (name) => `${pascalCase(name)}Instruction`,
+  programInstructionsEnumVariant: (name) => `${pascalCase(name)}`,
+  programInstructionsIdentifierFunction: (name) => `identify${pascalCase(name)}Instruction`,
+  programInstructionsParseFunction: (name) => `parse${pascalCase(name)}Instruction`,
+  programInstructionsParsedUnionType: (name) => `Parsed${pascalCase(name)}Instruction`,
+  programIsErrorFunction: (name) => `is${pascalCase(name)}Error`,
+  programPluginAccountKey: (name) => `${camelCase(name)}`,
+  programPluginAccountsType: (name) => `${pascalCase(name)}PluginAccounts`,
+  programPluginFunction: (name) => `${camelCase(name)}Program`,
+  programPluginInstructionKey: (name) => `${camelCase(name)}`,
+  programPluginInstructionsType: (name) => `${pascalCase(name)}PluginInstructions`,
+  programPluginKey: (name) => `${camelCase(name)}`,
+  programPluginRequirementsType: (name) => `${pascalCase(name)}PluginRequirements`,
+  programPluginType: (name) => `${pascalCase(name)}Plugin`,
+  resolverFunction: (name) => `${camelCase(name)}`
+};
+
+// src/utils/options.ts
+var DEFAULT_KIT_IMPORT_STRATEGY = "preferRoot";
 var DEFAULT_DEPENDENCY_VERSIONS = {
   "@solana/accounts": "^6.0.0",
   "@solana/addresses": "^6.0.0",
@@ -459,23 +323,16 @@ var DEFAULT_DEPENDENCY_VERSIONS = {
   "@solana/kit": "^6.0.0",
   "@solana/programs": "^6.0.0",
   "@solana/rpc-types": "^6.0.0",
-  "@solana/signers": "^6.0.0"
-};
-async function syncPackageJson(renderMap, formatCode, options) {
-  const shouldSyncPackageJson = options.syncPackageJson ?? false;
-  const packageFolder = options.packageFolder;
-  if (!packageFolder) {
-    if (shouldSyncPackageJson) {
-      logWarn("Cannot sync package.json. Please provide the 'packageFolder' option.");
-    }
-    return;
-  }
+  "@solana/signers": "^6.0.0"
+};
+async function syncPackageJson(renderMap, formatCode, packageFolder, options) {
+  const shouldSyncPackageJson = options.syncPackageJson ?? true;
   const packageJsonPath = joinPath(packageFolder, "package.json");
   const usedDependencies = getUsedDependencyVersions(
     renderMap,
     options.dependencyMap ?? {},
     options.dependencyVersions ?? {},
-    options.useGranularImports ?? false
+    options.kitImportStrategy ?? DEFAULT_KIT_IMPORT_STRATEGY
   );
   if (!shouldSyncPackageJson) {
     if (fileExists(packageJsonPath)) {
@@ -563,13 +420,13 @@ function checkExistingPackageJson(packageJson, dependencyVersions) {
 ${missingList}${outdatedList}`
   );
 }
-function getUsedDependencyVersions(renderMap, dependencyMap, dependencyVersions, useGranularImports) {
+function getUsedDependencyVersions(renderMap, dependencyMap, dependencyVersions, kitImportStrategy) {
   const dependencyVersionsWithDefaults = {
     ...DEFAULT_DEPENDENCY_VERSIONS,
     ...dependencyVersions
   };
   const fragment2 = mergeFragments([...renderMap.values()], () => "");
-  const usedDependencies = getExternalDependencies(fragment2.imports, dependencyMap, useGranularImports);
+  const usedDependencies = getExternalDependencies(fragment2.imports, dependencyMap, kitImportStrategy);
   const [usedDependencyVersion, missingDependencies] = [...usedDependencies].reduce(
     ([acc, missingDependencies2], dependency) => {
       const version = dependencyVersionsWithDefaults[dependency];
@@ -622,7 +479,173 @@ async function writePackageJson(packageJson, packageJsonPath, formatCode) {
   writeFile(packageJsonPath, formattedContent);
 }
 
-// src/fragments/accountFetchHelpers.ts
+// src/utils/typeManifest.ts
+function typeManifest(input = {}) {
+  return Object.freeze({
+    decoder: fragment``,
+    encoder: fragment``,
+    isEnum: false,
+    looseType: fragment``,
+    strictType: fragment``,
+    value: fragment``,
+    ...input
+  });
+}
+function mergeTypeManifests(manifests, options = {}) {
+  const { mergeTypes, mergeCodecs, mergeValues } = options;
+  const merge = (fragmentFn, mergeFn) => mergeFn ? mergeFragments(manifests.map(fragmentFn), mergeFn) : fragment``;
+  return Object.freeze({
+    decoder: merge((m) => m.decoder, mergeCodecs),
+    encoder: merge((m) => m.encoder, mergeCodecs),
+    isEnum: false,
+    looseType: merge((m) => m.looseType, mergeTypes),
+    strictType: merge((m) => m.strictType, mergeTypes),
+    value: merge((m) => m.value, mergeValues)
+  });
+}
+
+// src/utils/importMap.ts
+var DEFAULT_EXTERNAL_MODULE_MAP = {
+  solanaAccounts: "@solana/kit",
+  solanaAddresses: "@solana/kit",
+  solanaCodecsCore: "@solana/kit",
+  solanaCodecsDataStructures: "@solana/kit",
+  solanaCodecsNumbers: "@solana/kit",
+  solanaCodecsStrings: "@solana/kit",
+  solanaErrors: "@solana/kit",
+  solanaInstructionPlans: "@solana/kit",
+  solanaInstructions: "@solana/kit",
+  solanaOptions: "@solana/kit",
+  solanaPluginCore: "@solana/kit",
+  solanaPluginInterfaces: "@solana/kit",
+  solanaProgramClientCore: "@solana/kit/program-client-core",
+  solanaPrograms: "@solana/kit",
+  solanaRpcApi: "@solana/kit",
+  solanaRpcTypes: "@solana/kit",
+  solanaSigners: "@solana/kit"
+};
+var DEFAULT_GRANULAR_EXTERNAL_MODULE_MAP = {
+  solanaAccounts: "@solana/accounts",
+  solanaAddresses: "@solana/addresses",
+  solanaCodecsCore: "@solana/codecs",
+  solanaCodecsDataStructures: "@solana/codecs",
+  solanaCodecsNumbers: "@solana/codecs",
+  solanaCodecsStrings: "@solana/codecs",
+  solanaErrors: "@solana/errors",
+  solanaInstructionPlans: "@solana/instruction-plans",
+  solanaInstructions: "@solana/instructions",
+  solanaOptions: "@solana/codecs",
+  solanaPluginCore: "@solana/plugin-core",
+  solanaPluginInterfaces: "@solana/plugin-interfaces",
+  solanaProgramClientCore: "@solana/program-client-core",
+  solanaPrograms: "@solana/programs",
+  solanaRpcApi: "@solana/rpc-api",
+  solanaRpcTypes: "@solana/rpc-types",
+  solanaSigners: "@solana/signers"
+};
+var DEFAULT_INTERNAL_MODULE_MAP = {
+  errors: "../errors",
+  generated: "..",
+  generatedAccounts: "../accounts",
+  generatedErrors: "../errors",
+  generatedInstructions: "../instructions",
+  generatedPdas: "../pdas",
+  generatedPrograms: "../programs",
+  generatedTypes: "../types",
+  hooked: "../../hooked",
+  shared: "../shared",
+  types: "../types"
+};
+function createImportMap() {
+  return Object.freeze(/* @__PURE__ */ new Map());
+}
+function parseImportInput(input) {
+  const matches = input.match(/^(type )?([^ ]+)(?: as (.+))?$/);
+  if (!matches) return Object.freeze({ importedIdentifier: input, isType: false, usedIdentifier: input });
+  const [_, isType, name, alias] = matches;
+  return Object.freeze({
+    importedIdentifier: name,
+    isType: !!isType,
+    usedIdentifier: alias ?? name
+  });
+}
+function addToImportMap(importMap, module, imports) {
+  const parsedImports = imports.map(parseImportInput).map((i) => [i.usedIdentifier, i]);
+  return mergeImportMaps([importMap, /* @__PURE__ */ new Map([[module, new Map(parsedImports)]])]);
+}
+function removeFromImportMap(importMap, module, usedIdentifiers) {
+  const newMap = new Map(importMap);
+  const newModuleMap = new Map(newMap.get(module));
+  usedIdentifiers.forEach((usedIdentifier) => {
+    newModuleMap.delete(usedIdentifier);
+  });
+  if (newModuleMap.size === 0) {
+    newMap.delete(module);
+  } else {
+    newMap.set(module, newModuleMap);
+  }
+  return Object.freeze(newMap);
+}
+function mergeImportMaps(importMaps) {
+  if (importMaps.length === 0) return createImportMap();
+  if (importMaps.length === 1) return importMaps[0];
+  const mergedMap = new Map(importMaps[0]);
+  for (const map of importMaps.slice(1)) {
+    for (const [module, imports] of map) {
+      const mergedModuleMap = mergedMap.get(module) ?? /* @__PURE__ */ new Map();
+      for (const [usedIdentifier, importInfo] of imports) {
+        const existingImportInfo = mergedModuleMap.get(usedIdentifier);
+        const shouldOverwriteTypeOnly = existingImportInfo && existingImportInfo.importedIdentifier === importInfo.importedIdentifier && existingImportInfo.isType && !importInfo.isType;
+        if (!existingImportInfo || shouldOverwriteTypeOnly) {
+          mergedModuleMap.set(usedIdentifier, importInfo);
+        }
+      }
+      mergedMap.set(module, mergedModuleMap);
+    }
+  }
+  return Object.freeze(mergedMap);
+}
+function importMapToString(importMap, dependencyMap = {}, kitImportStrategy = DEFAULT_KIT_IMPORT_STRATEGY) {
+  const resolvedMap = resolveImportMapModules(importMap, dependencyMap, kitImportStrategy);
+  return [...resolvedMap.entries()].sort(([a], [b]) => {
+    const relative = Number(a.startsWith(".")) - Number(b.startsWith("."));
+    if (relative !== 0) return relative;
+    return a.localeCompare(b);
+  }).map(([module, imports]) => {
+    const innerImports = [...imports.values()].map(importInfoToString).sort((a, b) => a.localeCompare(b)).join(", ");
+    return `import { ${innerImports} } from '${module}';`;
+  }).join("\n");
+}
+function getExternalDependencies(importMap, dependencyMap, kitImportStrategy) {
+  const resolvedImports = resolveImportMapModules(importMap, dependencyMap, kitImportStrategy);
+  return new Set(
+    [...resolvedImports.keys()].filter((module) => !module.startsWith(".")).map((module) => {
+      const subPathExportIndex = module.startsWith("@") ? 2 : 1;
+      return module.split("/").slice(0, subPathExportIndex).join("/");
+    })
+  );
+}
+function resolveImportMapModules(importMap, dependencyMap, kitImportStrategy) {
+  const defaultExternalModuleMap = kitImportStrategy === "granular" ? DEFAULT_GRANULAR_EXTERNAL_MODULE_MAP : DEFAULT_EXTERNAL_MODULE_MAP;
+  if (kitImportStrategy === "preferRoot") {
+    defaultExternalModuleMap["solanaProgramClientCore"] = "@solana/program-client-core";
+  }
+  const dependencyMapWithDefaults = {
+    ...defaultExternalModuleMap,
+    ...DEFAULT_INTERNAL_MODULE_MAP,
+    ...dependencyMap
+  };
+  return mergeImportMaps(
+    [...importMap.entries()].map(([module, imports]) => {
+      const resolvedModule = dependencyMapWithDefaults[module] ?? module;
+      return /* @__PURE__ */ new Map([[resolvedModule, imports]]);
+    })
+  );
+}
+function importInfoToString({ importedIdentifier, isType, usedIdentifier }) {
+  const alias = importedIdentifier !== usedIdentifier ? ` as ${usedIdentifier}` : "";
+  return `${isType ? "type " : ""}${importedIdentifier}${alias}`;
+}
 function getAccountFetchHelpersFragment(scope) {
   const { accountPath, typeManifest: typeManifest2, nameApi, customAccountData } = scope;
   const accountNode = getLastNodeFromPath(accountPath);
@@ -1182,28 +1205,45 @@ function getInstructionInputDefaultFragment(scope) {
     }
     return fragment`args.${inputName} = ${renderedValue};`;
   };
-  const expectTransactionSigner = use("expectTransactionSigner", "shared");
-  const expectSome = use("expectSome", "shared");
-  const expectAddress = use("expectAddress", "shared");
-  const expectProgramDerivedAddress = use("expectProgramDerivedAddress", "shared");
+  const getNonNullResolvedInstructionInput = use("getNonNullResolvedInstructionInput", "solanaProgramClientCore");
+  const getResolvedInstructionAccountAsTransactionSigner = use(
+    "getResolvedInstructionAccountAsTransactionSigner",
+    "solanaProgramClientCore"
+  );
+  const getAddressFromResolvedInstructionAccount = use(
+    "getAddressFromResolvedInstructionAccount",
+    "solanaProgramClientCore"
+  );
+  const getResolvedInstructionAccountAsProgramDerivedAddress = use(
+    "getResolvedInstructionAccountAsProgramDerivedAddress",
+    "solanaProgramClientCore"
+  );
   const addressType = use("type Address", "solanaAddresses");
   switch (defaultValue.kind) {
     case "accountValueNode":
       const name = camelCase(defaultValue.name);
       if (input.kind === "instructionAccountNode" && input.resolvedIsSigner && !input.isSigner) {
-        return defaultFragment(fragment`${expectTransactionSigner}(accounts.${name}.value).address`);
+        return defaultFragment(
+          fragment`${getResolvedInstructionAccountAsTransactionSigner}("${name}", accounts.${name}.value).address`
+        );
       }
       if (input.kind === "instructionAccountNode") {
-        return defaultFragment(fragment`${expectSome}(accounts.${name}.value)`);
+        return defaultFragment(
+          fragment`${getNonNullResolvedInstructionInput}("${name}", accounts.${name}.value)`
+        );
       }
-      return defaultFragment(fragment`${expectAddress}(accounts.${name}.value)`);
+      return defaultFragment(
+        fragment`${getAddressFromResolvedInstructionAccount}("${name}", accounts.${name}.value)`
+      );
     case "pdaValueNode":
       let pdaProgramValue;
       if (isNode(defaultValue.programId, "accountValueNode")) {
-        pdaProgramValue = fragment`${expectAddress}(accounts.${camelCase(defaultValue.programId.name)}.value)`;
+        const name2 = camelCase(defaultValue.programId.name);
+        pdaProgramValue = fragment`${getAddressFromResolvedInstructionAccount}("${name2}", accounts.${name2}.value)`;
       }
       if (isNode(defaultValue.programId, "argumentValueNode")) {
-        pdaProgramValue = fragment`${expectAddress}(args.${camelCase(defaultValue.programId.name)})`;
+        const name2 = camelCase(defaultValue.programId.name);
+        pdaProgramValue = fragment`${getAddressFromResolvedInstructionAccount}("${name2}", args.${name2})`;
       }
       if (isNode(defaultValue.pda, "pdaNode")) {
         let pdaProgram = fragment`programAddress`;
@@ -1226,13 +1266,15 @@ function getInstructionInputDefaultFragment(scope) {
             const valueSeed = defaultValue.seeds.find((s) => s.name === seed.name)?.value;
             if (!valueSeed) return [];
             if (isNode(valueSeed, "accountValueNode")) {
+              const name2 = camelCase(valueSeed.name);
               return [
-                fragment`${typeManifest2.encoder}.encode(${expectAddress}(accounts.${camelCase(valueSeed.name)}.value))`
+                fragment`${typeManifest2.encoder}.encode(${getAddressFromResolvedInstructionAccount}("${name2}", accounts.${name2}.value))`
               ];
             }
             if (isNode(valueSeed, "argumentValueNode")) {
+              const name2 = camelCase(valueSeed.name);
               return [
-                fragment`${typeManifest2.encoder}.encode(${expectSome}(args.${camelCase(valueSeed.name)}))`
+                fragment`${typeManifest2.encoder}.encode(${getNonNullResolvedInstructionInput}("${name2}", args.${name2}))`
               ];
             }
             const valueManifest2 = visit(valueSeed, typeManifestVisitor);
@@ -1251,10 +1293,12 @@ function getInstructionInputDefaultFragment(scope) {
       const pdaArgs = [];
       const pdaSeeds = defaultValue.seeds.map((seed) => {
         if (isNode(seed.value, "accountValueNode")) {
-          return fragment`${seed.name}: ${expectAddress}(accounts.${camelCase(seed.value.name)}.value)`;
+          const name2 = camelCase(seed.value.name);
+          return fragment`${seed.name}: ${getAddressFromResolvedInstructionAccount}("${name2}", accounts.${name2}.value)`;
         }
         if (isNode(seed.value, "argumentValueNode")) {
-          return fragment`${seed.name}: ${expectSome}(args.${camelCase(seed.value.name)})`;
+          const name2 = camelCase(seed.value.name);
+          return fragment`${seed.name}: ${getNonNullResolvedInstructionInput}("${name2}", args.${name2})`;
         }
         return pipe(
           visit(seed.value, typeManifestVisitor).value,
@@ -1289,10 +1333,12 @@ function getInstructionInputDefaultFragment(scope) {
       return fragment``;
     case "accountBumpValueNode":
       return defaultFragment(
-        fragment`${expectProgramDerivedAddress}(accounts.${camelCase(defaultValue.name)}.value)[1]`
+        fragment`${getResolvedInstructionAccountAsProgramDerivedAddress}("${camelCase(defaultValue.name)}", accounts.${camelCase(defaultValue.name)}.value)[1]`
       );
     case "argumentValueNode":
-      return defaultFragment(fragment`${expectSome}(args.${camelCase(defaultValue.name)})`);
+      return defaultFragment(
+        fragment`${getNonNullResolvedInstructionInput}("${camelCase(defaultValue.name)}", args.${camelCase(defaultValue.name)})`
+      );
     case "resolverValueNode":
       const resolverFunction = use(nameApi.resolverFunction(defaultValue.name), getImportFrom(defaultValue));
       const resolverAwait = useAsync && asyncResolvers.includes(defaultValue.name) ? "await " : "";
@@ -1555,7 +1601,7 @@ function getArgumentValueNodeFragment2(remainingAccounts, scope) {
     return fragment`${argumentArray}.map((address) => ({ address, role: ${role} }))`;
   }
   if (isSigner === "either") {
-    return fragment`${argumentArray}.map((addressOrSigner) => (${use("isTransactionSigner", "shared")}(addressOrSigner) ? { address: addressOrSigner.address, role: ${role}, signer: addressOrSigner } : { address: addressOrSigner, role: ${role} }))`;
+    return fragment`${argumentArray}.map((addressOrSigner) => (typeof addressOrSigner === "string" ? { address: addressOrSigner, role: ${role} } : { address: addressOrSigner.address, role: ${role}, signer: addressOrSigner }))`;
   }
   return fragment`${argumentArray}.map((signer) => ({ address: signer.address, role: ${signerRole}, signer }))`;
 }
@@ -1655,7 +1701,7 @@ function getAccountsInitializationFragment(instructionNode) {
   );
   return fragment` // Original accounts.
 const originalAccounts = { ${accounts} }
-const accounts = originalAccounts as Record<keyof typeof originalAccounts, ${use("type ResolvedAccount", "shared")}>;
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ${use("type ResolvedInstructionAccount", "solanaProgramClientCore")}>;
 `;
 }
 function getArgumentsInitializationFragment(hasAnyArgs, renamedArgs) {
@@ -1680,9 +1726,11 @@ function getReturnStatementFragment(scope) {
   const optionalAccountStrategy = instructionNode.optionalAccountStrategy ?? "programId";
   const hasAccounts = instructionNode.accounts.length > 0;
   const hasLegacyOptionalAccounts = instructionNode.optionalAccountStrategy === "omitted" && instructionNode.accounts.some((account) => account.isOptional);
-  const getAccountMeta = hasAccounts ? fragment`const getAccountMeta = ${use("getAccountMetaFactory", "shared")}(programAddress, '${optionalAccountStrategy}');` : "";
+  const getAccountMeta = hasAccounts ? fragment`const getAccountMeta = ${use("getAccountMetaFactory", "solanaProgramClientCore")}(programAddress, '${optionalAccountStrategy}');` : "";
   const accountItems = [
-    ...instructionNode.accounts.map((account) => `getAccountMeta(accounts.${camelCase(account.name)})`),
+    ...instructionNode.accounts.map(
+      (account) => `getAccountMeta("${camelCase(account.name)}", accounts.${camelCase(account.name)})`
+    ),
     ...hasRemainingAccounts ? ["...remainingAccounts"] : []
   ].join(", ");
   let accounts;
@@ -1712,7 +1760,7 @@ function getReturnStatementFragment(scope) {
 function getReturnTypeFragment(instructionTypeFragment, hasByteDeltas, useAsync) {
   return pipe(
     instructionTypeFragment,
-    (f) => hasByteDeltas ? fragment`${f} & ${use("type InstructionWithByteDelta", "shared")}` : f,
+    (f) => hasByteDeltas ? fragment`${f} & ${use("type InstructionWithByteDelta", "solanaProgramClientCore")}` : f,
     (f) => useAsync ? fragment`Promise<${f}>` : f
   );
 }
@@ -1824,9 +1872,10 @@ function getFunctionFragment(scope) {
   );
   let accountHelpers;
   if (hasAccounts) {
+    const solanaError = use("SolanaError", "solanaErrors");
+    const solanaErrorCode = use("SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS", "solanaErrors");
     accountHelpers = fragment`if (instruction.accounts.length < ${minimumNumberOfAccounts}) {
-  // TODO: Coded error.
-  throw new Error('Not enough accounts');
+  throw new ${solanaError}(${solanaErrorCode}, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: ${minimumNumberOfAccounts} });
 }
 let accountIndex = 0;
 const getNextAccount = () => {
@@ -2044,30 +2093,27 @@ function getProgramAccountsIdentifierFunctionFragment(scope) {
   if (!hasAccountDiscriminators) return;
   const programAccountsEnum = nameApi.programAccountsEnum(programNode.name);
   const programAccountsIdentifierFunction = nameApi.programAccountsIdentifierFunction(programNode.name);
-  return pipe(
-    mergeFragments(
-      accountsWithDiscriminators.map((account) => {
-        const variant = nameApi.programAccountsEnumVariant(account.name);
-        return getDiscriminatorConditionFragment({
-          ...scope,
-          dataName: "data",
-          discriminators: account.discriminators ?? [],
-          ifTrue: `return ${programAccountsEnum}.${variant};`,
-          struct: resolveNestedTypeNode(account.data)
-        });
-      }),
-      (c) => c.join("\n")
-    ),
-    (f) => mapFragmentContent(
-      f,
-      (discriminators) => `export function ${programAccountsIdentifierFunction}(account: { data: ReadonlyUint8Array } | ReadonlyUint8Array): ${programAccountsEnum} {
-const data = 'data' in account ? account.data : account;
-${discriminators}
-throw new Error("The provided account could not be identified as a ${programNode.name} account.")
-}`
-    ),
-    (f) => addFragmentImports(f, "solanaCodecsCore", ["type ReadonlyUint8Array"])
+  const discriminatorsFragment = mergeFragments(
+    accountsWithDiscriminators.map((account) => {
+      const variant = nameApi.programAccountsEnumVariant(account.name);
+      return getDiscriminatorConditionFragment({
+        ...scope,
+        dataName: "data",
+        discriminators: account.discriminators ?? [],
+        ifTrue: `return ${programAccountsEnum}.${variant};`,
+        struct: resolveNestedTypeNode(account.data)
+      });
+    }),
+    (c) => c.join("\n")
   );
+  const readonlyUint8Array = use("type ReadonlyUint8Array", "solanaCodecsCore");
+  const solanaError = use("SolanaError", "solanaErrors");
+  const solanaErrorCode = use("SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT", "solanaErrors");
+  return fragment`export function ${programAccountsIdentifierFunction}(account: { data: ${readonlyUint8Array} } | ${readonlyUint8Array}): ${programAccountsEnum} {
+    const data = 'data' in account ? account.data : account;
+    ${discriminatorsFragment}
+    throw new ${solanaError}(${solanaErrorCode}, { accountData: data, programName: "${programNode.name}" });
+}`;
 }
 function getProgramConstantFragment(scope) {
   const { programNode, nameApi } = scope;
@@ -2124,18 +2170,14 @@ function getProgramInstructionsIdentifierFunctionFragment(scope) {
     }),
     (c) => c.join("\n")
   );
-  return pipe(
-    discriminatorsFragment,
-    (f) => mapFragmentContent(
-      f,
-      (discriminators) => `export function ${programInstructionsIdentifierFunction}(instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array): ${programInstructionsEnum} {
-const data = 'data' in instruction ? instruction.data : instruction;
-${discriminators}
-throw new Error("The provided instruction could not be identified as a ${programNode.name} instruction.")
-}`
-    ),
-    (f) => addFragmentImports(f, "solanaCodecsCore", ["type ReadonlyUint8Array"])
-  );
+  const readonlyUint8Array = use("type ReadonlyUint8Array", "solanaCodecsCore");
+  const solanaError = use("SolanaError", "solanaErrors");
+  const solanaErrorCode = use("SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION", "solanaErrors");
+  return fragment`export function ${programInstructionsIdentifierFunction}(instruction: { data: ${readonlyUint8Array} } | ${readonlyUint8Array}): ${programInstructionsEnum} {
+    const data = 'data' in instruction ? instruction.data : instruction;
+    ${discriminatorsFragment}
+    throw new ${solanaError}(${solanaErrorCode}, { instructionData: data, programName: "${programNode.name}" });
+}`;
 }
 function getProgramInstructionsParsedUnionTypeFragment(scope) {
   const { programNode, allInstructions, nameApi } = scope;
@@ -2179,6 +2221,8 @@ function getProgramInstructionsParseFunctionFragment(scope) {
     }),
     (c) => c.join("\n")
   );
+  const solanaError = use("SolanaError", "solanaErrors");
+  const solanaErrorCode = use("SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE", "solanaErrors");
   return fragment`
         export function ${parseFunction}<TProgram extends string>(
             instruction: ${use("type Instruction", "solanaInstructions")}<TProgram> 
@@ -2187,15 +2231,187 @@ function getProgramInstructionsParseFunctionFragment(scope) {
             const instructionType = ${programInstructionsIdentifierFunction}(instruction);
             switch (instructionType) {
                 ${switchCases}
-                default: throw new Error(\`Unrecognized instruction type: \${instructionType as string}\`);
+                default: throw new ${solanaError}(${solanaErrorCode}, { instructionType: instructionType as string, programName: "${programNode.name}" });
             }
         }`;
 }
+function getProgramPluginFragment(scope) {
+  if (scope.programNode.accounts.length === 0 && scope.programNode.instructions.length === 0) return;
+  const resolvedInstructionInputVisitor = getResolvedInstructionInputsVisitor();
+  const asyncInstructions = scope.programNode.instructions.filter(
+    (instruction) => hasAsyncFunction(instruction, visit(instruction, resolvedInstructionInputVisitor), scope.asyncResolvers)
+  ).map((i) => i.name);
+  return mergeFragments(
+    [
+      getProgramPluginTypeFragment(scope),
+      getProgramPluginAccountsTypeFragment(scope),
+      getProgramPluginInstructionsTypeFragment({ ...scope, asyncInstructions }),
+      getProgramPluginRequirementsTypeFragment(scope),
+      getProgramPluginFunctionFragment({ ...scope, asyncInstructions }),
+      getMakeOptionalHelperTypeFragment(scope)
+    ],
+    (c) => c.join("\n\n")
+  );
+}
+function getProgramPluginTypeFragment(scope) {
+  const { programNode, nameApi } = scope;
+  const programPluginType = nameApi.programPluginType(programNode.name);
+  const programPluginAccountsType = nameApi.programPluginAccountsType(programNode.name);
+  const programPluginInstructionsType = nameApi.programPluginInstructionsType(programNode.name);
+  const fields = mergeFragments(
+    [
+      programNode.accounts.length > 0 ? fragment`accounts: ${programPluginAccountsType};` : void 0,
+      programNode.instructions.length > 0 ? fragment`instructions: ${programPluginInstructionsType};` : void 0
+    ],
+    (c) => c.join(" ")
+  );
+  return fragment`export type ${programPluginType} = { ${fields} }`;
+}
+function getProgramPluginAccountsTypeFragment(scope) {
+  const { programNode, nameApi } = scope;
+  if (programNode.accounts.length === 0) return;
+  const programPluginAccountsType = nameApi.programPluginAccountsType(programNode.name);
+  const selfFetchFunctions = use("type SelfFetchFunctions", "solanaProgramClientCore");
+  const fields = mergeFragments(
+    programNode.accounts.map((account) => {
+      const name = nameApi.programPluginAccountKey(account.name);
+      const codecFunction = use("type " + nameApi.codecFunction(account.name), "generatedAccounts");
+      const fromType = use("type " + nameApi.dataArgsType(account.name), "generatedAccounts");
+      const toType = use("type " + nameApi.dataType(account.name), "generatedAccounts");
+      return fragment`${name}: ReturnType<typeof ${codecFunction}> & ${selfFetchFunctions}<${fromType}, ${toType}>;`;
+    }),
+    (c) => c.join(" ")
+  );
+  return fragment`export type ${programPluginAccountsType} = { ${fields} }`;
+}
+function getProgramPluginInstructionsTypeFragment(scope) {
+  const { programNode, asyncInstructions, nameApi } = scope;
+  if (programNode.instructions.length === 0) return;
+  const programPluginInstructionsType = nameApi.programPluginInstructionsType(programNode.name);
+  const selfPlanAndSendFunctions = use("type SelfPlanAndSendFunctions", "solanaProgramClientCore");
+  const fields = mergeFragments(
+    programNode.instructions.map((instruction) => {
+      const name = nameApi.programPluginInstructionKey(instruction.name);
+      const isAsync = asyncInstructions.includes(instruction.name);
+      let instructionInputType = isAsync ? use("type " + nameApi.instructionAsyncInputType(instruction.name), "generatedInstructions") : use("type " + nameApi.instructionSyncInputType(instruction.name), "generatedInstructions");
+      const instructionFunction = isAsync ? use("type " + nameApi.instructionAsyncFunction(instruction.name), "generatedInstructions") : use("type " + nameApi.instructionSyncFunction(instruction.name), "generatedInstructions");
+      const payerDefaultValues = getPayerDefaultValues(instruction);
+      if (payerDefaultValues.length > 0) {
+        const fieldStringUnion = payerDefaultValues.map(({ name: name2 }) => `"${name2}"`).join(" | ");
+        instructionInputType = fragment`MakeOptional<${instructionInputType}, ${fieldStringUnion}>`;
+      }
+      return fragment`${name}: (input: ${instructionInputType}) => ReturnType<typeof ${instructionFunction}> & ${selfPlanAndSendFunctions};`;
+    }),
+    (c) => c.join(" ")
+  );
+  return fragment`export type ${programPluginInstructionsType} = { ${fields} }`;
+}
+function getProgramPluginRequirementsTypeFragment(scope) {
+  const { programNode, nameApi } = scope;
+  const programRequirementsType = nameApi.programPluginRequirementsType(programNode.name);
+  const clientWithRpc = fragment`${use("type ClientWithRpc", "solanaPluginInterfaces")}<${use("type GetAccountInfoApi", "solanaRpcApi")} & ${use("type GetMultipleAccountsApi", "solanaRpcApi")}>`;
+  const clientWithPayer = use("type ClientWithPayer", "solanaPluginInterfaces");
+  const clientWithTransactionPlanning = use("type ClientWithTransactionPlanning", "solanaPluginInterfaces");
+  const clientWithTransactionSending = use("type ClientWithTransactionSending", "solanaPluginInterfaces");
+  const hasAccounts = programNode.accounts.length > 0;
+  const hasInstructions = programNode.instructions.length > 0;
+  const requirements = mergeFragments(
+    [
+      hasAccounts ? clientWithRpc : void 0,
+      hasPayerDefaultValues(programNode) ? clientWithPayer : void 0,
+      hasInstructions ? clientWithTransactionPlanning : void 0,
+      hasInstructions ? clientWithTransactionSending : void 0
+    ],
+    (c) => c.join(" & ")
+  );
+  return fragment`export type ${programRequirementsType} = ${requirements}`;
+}
+function getProgramPluginFunctionFragment(scope) {
+  const { programNode, nameApi } = scope;
+  const programPluginFunction = nameApi.programPluginFunction(programNode.name);
+  const programPluginType = nameApi.programPluginType(programNode.name);
+  const programPluginRequirementsType = nameApi.programPluginRequirementsType(programNode.name);
+  const programPluginKey = nameApi.programPluginKey(programNode.name);
+  const fields = mergeFragments(
+    [getProgramPluginAccountsObjectFragment(scope), getProgramPluginInstructionsObjectFragment(scope)],
+    (c) => c.join(", ")
+  );
+  return fragment`export function ${programPluginFunction}() {
+    return <T extends ${programPluginRequirementsType}>(client: T) => {
+        return { ...client, ${programPluginKey}: <${programPluginType}>{ ${fields} } };
+    };
+}`;
+}
+function getProgramPluginAccountsObjectFragment(scope) {
+  const { programNode, nameApi } = scope;
+  if (programNode.accounts.length === 0) return;
+  const fields = mergeFragments(
+    programNode.accounts.map((account) => {
+      const name = nameApi.programPluginAccountKey(account.name);
+      const addSelfFetchFunctions = use("addSelfFetchFunctions", "solanaProgramClientCore");
+      const codecFunction = use(nameApi.codecFunction(account.name), "generatedAccounts");
+      return fragment`${name}: ${addSelfFetchFunctions}(client, ${codecFunction}())`;
+    }),
+    (c) => c.join(", ")
+  );
+  return fragment`accounts: { ${fields} }`;
+}
+function getProgramPluginInstructionsObjectFragment(scope) {
+  const { programNode, nameApi, asyncInstructions } = scope;
+  if (programNode.instructions.length === 0) return;
+  const fields = mergeFragments(
+    programNode.instructions.map((instruction) => {
+      const name = nameApi.programPluginInstructionKey(instruction.name);
+      const isAsync = asyncInstructions.includes(instruction.name);
+      const instructionFunction = isAsync ? use(nameApi.instructionAsyncFunction(instruction.name), "generatedInstructions") : use(nameApi.instructionSyncFunction(instruction.name), "generatedInstructions");
+      const addSelfPlanAndSendFunctions = use("addSelfPlanAndSendFunctions", "solanaProgramClientCore");
+      const payerDefaultValues = getPayerDefaultValues(instruction);
+      let input = fragment`input`;
+      if (payerDefaultValues.length > 0) {
+        const fieldOverrides = mergeFragments(
+          payerDefaultValues.map(({ name: name2, signer }) => {
+            const signerDefault = signer ? "client.payer" : "client.payer.address";
+            return fragment`${name2}: input.${name2} ?? ${signerDefault}`;
+          }),
+          (c) => c.join(", ")
+        );
+        input = fragment`{ ...input, ${fieldOverrides} }`;
+      }
+      return fragment`${name}: input => ${addSelfPlanAndSendFunctions}(client, ${instructionFunction}(${input}))`;
+    }),
+    (c) => c.join(", ")
+  );
+  return fragment`instructions: { ${fields} }`;
+}
+function getMakeOptionalHelperTypeFragment(scope) {
+  if (!hasPayerDefaultValues(scope.programNode)) return;
+  return fragment`type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;`;
+}
+function hasPayerDefaultValues(programNode) {
+  return programNode.instructions.some((instruction) => getPayerDefaultValueNodes(instruction).length > 0);
+}
+function getPayerDefaultValues(instructionNode) {
+  const renamedArgs = getRenamedArgsMap(instructionNode);
+  return getPayerDefaultValueNodes(instructionNode).map((inputNode) => {
+    return isNode(inputNode, "instructionAccountNode") ? { name: inputNode.name, signer: inputNode.isSigner !== false } : { name: renamedArgs.get(inputNode.name) ?? inputNode.name, signer: false };
+  });
+}
+function getPayerDefaultValueNodes(instructionNode) {
+  return [
+    ...instructionNode.accounts.filter((a) => !a.isOptional && isNode(a.defaultValue, "payerValueNode")),
+    ...instructionNode.arguments.filter((a) => isNode(a.defaultValue, "payerValueNode"))
+  ];
+}
 
 // src/fragments/programPage.ts
 function getProgramPageFragment(scope) {
   return mergeFragments(
-    [getProgramConstantFragment(scope), getProgramAccountsFragment(scope), getProgramInstructionsFragment(scope)],
+    [
+      getProgramConstantFragment(scope),
+      getProgramAccountsFragment(scope),
+      getProgramInstructionsFragment(scope),
+      getProgramPluginFragment(scope)
+    ],
     (cs) => cs.join("\n\n")
   );
 }
@@ -2219,121 +2435,6 @@ function getRootIndexPageFragment(scope) {
     (cs) => cs.join("\n")
   );
 }
-function getSharedPageFragment() {
-  const sharedPage = fragment`/**
- * Asserts that the given value is not null or undefined.
- * @internal
- */
-export function expectSome<T>(value: T | null | undefined): T {
-  if (value === null || value === undefined) {
-    throw new Error('Expected a value but received null or undefined.');
-  }
-  return value;
-}
-
-/**
- * Asserts that the given value is a PublicKey.
- * @internal
- */
-export function expectAddress<T extends string = string>(
-  value: Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null | undefined
-): Address<T> {
-  if (!value) {
-    throw new Error('Expected a Address.');
-  }
-  if (typeof value === 'object' && "address" in value) {
-    return value.address;
-  }
-  if (Array.isArray(value)) {
-    return value[0] as Address<T>;
-  }
-  return value as Address<T>;
-}
-
-/**
- * Asserts that the given value is a PDA.
- * @internal
- */
-export function expectProgramDerivedAddress<T extends string = string>(
-  value: Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null | undefined
-): ProgramDerivedAddress<T> {
-  if (!value || !Array.isArray(value) || !isProgramDerivedAddress(value)) {
-    throw new Error('Expected a ProgramDerivedAddress.');
-  }
-  return value;
-}
-
-/**
- * Asserts that the given value is a TransactionSigner.
- * @internal
- */
-export function expectTransactionSigner<T extends string = string>(
-  value: Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null | undefined
-): TransactionSigner<T> {
-  if (!value || !isTransactionSigner(value)) {
-    throw new Error('Expected a TransactionSigner.');
-  }
-  return value;
-}
-
-/**
- * Defines an instruction account to resolve.
- * @internal
- */
-export type ResolvedAccount<T extends string = string, U extends Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null = Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null> = {
-  isWritable: boolean;
-  value: U;
-};
-
- /**
- * Defines an instruction that stores additional bytes on-chain.
- * @internal
- */
-export type InstructionWithByteDelta = {
-  byteDelta: number;
-};
-
-/**
-* Get account metas and signers from resolved accounts.
-* @internal
-*/
-export function getAccountMetaFactory(
-  programAddress: Address,
-  optionalAccountStrategy: 'omitted' | 'programId',
-) {
-  return (account: ResolvedAccount): AccountMeta | AccountSignerMeta | undefined => {
-    if (!account.value) {
-      if (optionalAccountStrategy === 'omitted') return;
-      return Object.freeze({ address: programAddress, role: AccountRole.READONLY });
-    }
-
-    const writableRole = account.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY;
-    return Object.freeze({
-      address: expectAddress(account.value),
-      role: isTransactionSigner(account.value) ? upgradeRoleToSigner(writableRole) : writableRole,
-      ...(isTransactionSigner(account.value) ? { signer: account.value } : {})
-    });
-  };
-}
-
-export function isTransactionSigner<TAddress extends string = string>(value: Address<TAddress> | ProgramDerivedAddress<TAddress> | TransactionSigner<TAddress>): value is TransactionSigner<TAddress> {
-  return !!value && typeof value === 'object' && 'address' in value && kitIsTransactionSigner(value);
-}`;
-  return pipe(
-    sharedPage,
-    (f) => addFragmentImports(f, "solanaAddresses", [
-      "type Address",
-      "isProgramDerivedAddress",
-      "type ProgramDerivedAddress"
-    ]),
-    (f) => addFragmentImports(f, "solanaInstructions", ["AccountRole", "type AccountMeta", "upgradeRoleToSigner"]),
-    (f) => addFragmentImports(f, "solanaSigners", [
-      "type AccountSignerMeta",
-      "isTransactionSigner as kitIsTransactionSigner",
-      "type TransactionSigner"
-    ])
-  );
-}
 function getTypeDiscriminatedUnionHelpersFragment(scope) {
   const { name, typeNode, nameApi } = scope;
   const isDiscriminatedUnion = isNode(typeNode, "enumTypeNode") && isDataEnum(typeNode);
@@ -3111,11 +3212,11 @@ function getRenderMapVisitor(options = {}) {
     dependencyMap: options.dependencyMap ?? {},
     dependencyVersions: options.dependencyVersions ?? {},
     getImportFrom: getImportFromFactory(options.linkOverrides ?? {}, customAccountData, customInstructionData),
+    kitImportStrategy: options.kitImportStrategy ?? DEFAULT_KIT_IMPORT_STRATEGY,
     linkables,
     nameApi: getNameApi({ ...DEFAULT_NAME_TRANSFORMERS, ...options.nameTransformers }),
     nonScalarEnums: (options.nonScalarEnums ?? []).map(camelCase),
-    renderParentInstructions: options.renderParentInstructions ?? false,
-    useGranularImports: options.useGranularImports ?? false
+    renderParentInstructions: options.renderParentInstructions ?? false
   };
   const typeManifestVisitor = getTypeManifestVisitor({ ...renderScopeWithTypeManifestVisitor, stack });
   const renderScope = { ...renderScopeWithTypeManifestVisitor, typeManifestVisitor };
@@ -3203,7 +3304,6 @@ function getRenderMapVisitor(options = {}) {
           leavesOnly: !renderScope.renderParentInstructions
         }).filter(isNotInternal);
         const definedTypesToExport = getAllDefinedTypes(node).filter(isNotInternal);
-        const hasAnythingToExport = programsToExport.length > 0 || accountsToExport.length > 0 || instructionsToExport.length > 0 || definedTypesToExport.length > 0;
         const scope = {
           accountsToExport,
           definedTypesToExport,
@@ -3219,7 +3319,6 @@ function getRenderMapVisitor(options = {}) {
             ["instructions/index.ts"]: asPage(getIndexPageFragment(instructionsToExport)),
             ["pdas/index.ts"]: asPage(getIndexPageFragment(pdasToExport)),
             ["programs/index.ts"]: asPage(getIndexPageFragment(programsToExport)),
-            ["shared/index.ts"]: hasAnythingToExport ? asPage(getSharedPageFragment()) : void 0,
             ["types/index.ts"]: asPage(getIndexPageFragment(definedTypesToExport))
           }),
           ...getAllPrograms(node).map((p) => visit(p, self))
@@ -3230,16 +3329,17 @@ function getRenderMapVisitor(options = {}) {
     (v) => recordLinkablesOnFirstVisitVisitor(v, linkables)
   );
 }
-function renderVisitor(path, options = {}) {
+function renderVisitor(packageFolder, options = {}) {
   return rootNodeVisitor(async (root) => {
+    const generatedFolder = joinPath(packageFolder, options.generatedFolder ?? "src/generated");
     if (options.deleteFolderBeforeRendering ?? true) {
-      deleteDirectory(path);
+      deleteDirectory(generatedFolder);
     }
     let renderMap = visit(root, getRenderMapVisitor(options));
-    const formatCode = await getCodeFormatter(options);
+    const formatCode = await getCodeFormatter(packageFolder, options);
     renderMap = await mapRenderMapContentAsync(renderMap, formatCode);
-    await syncPackageJson(renderMap, formatCode, options);
-    writeRenderMap(renderMap, path);
+    await syncPackageJson(renderMap, formatCode, packageFolder, options);
+    writeRenderMap(renderMap, generatedFolder);
   });
 }