@0xsequence/catapult 1.3.17 → 1.5.0

package/src/lib/parsers/artifact/__tests__/fixtures/missing-abi.json

@@ -1,4 +0,0 @@
-{
-  "contractName": "MissingAbi",
-  "bytecode": "0x608060405234801561001057600080fd5b50"
-} 

package/src/lib/parsers/artifact/__tests__/fixtures/missing-bytecode.json

@@ -1,11 +0,0 @@
-{
-  "contractName": "MissingBytecode",
-  "abi": [
-    {
-      "type": "function",
-      "name": "test",
-      "inputs": [],
-      "outputs": []
-    }
-  ]
-} 

package/src/lib/parsers/artifact/__tests__/fixtures/missing-contract-name.json

@@ -1,11 +0,0 @@
-{
-  "abi": [
-    {
-      "type": "function",
-      "name": "test",
-      "inputs": [],
-      "outputs": []
-    }
-  ],
-  "bytecode": "0x608060405234801561001057600080fd5b50"
-} 

package/src/lib/parsers/artifact/__tests__/fixtures/simple-artifact.json

@@ -1,40 +0,0 @@
-{
-  "contractName": "SimpleToken",
-  "abi": [
-    {
-      "type": "constructor",
-      "inputs": [
-        {
-          "name": "name",
-          "type": "string"
-        },
-        {
-          "name": "symbol", 
-          "type": "string"
-        }
-      ]
-    },
-    {
-      "type": "function",
-      "name": "transfer",
-      "inputs": [
-        {
-          "name": "to",
-          "type": "address"
-        },
-        {
-          "name": "amount",
-          "type": "uint256"
-        }
-      ],
-      "outputs": [
-        {
-          "name": "",
-          "type": "bool"
-        }
-      ]
-    }
-  ],
-  "bytecode": "0x608060405234801561001057600080fd5b506040516103e93803806103e98339818101604052810190610032919061007a565b80600090805190602001906100489291906100ad565b50506100fb565b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6100a982610060565b810181811067ffffffffffffffff821117156100c8576100c7610071565b5b80604052505050565b60006100db6100a0565b90506100e782826100a0565b919050565b6000819050919050565b6100ff816100ec565b811461010a57600080fd5b50565b60008151905061011c816100f6565b92915050565b6000602082840312156101385761013761005b565b5b60006101468482850161010d565b91505092915050565b6102df8061015f6000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c8063a9059cbb1461003b578063dd62ed3e14610057575b600080fd5b61005560048036038101906100509190610123565b610087565b005b610071600480360381019061006c9190610163565b6100a1565b60405161007e91906101b2565b60405180910390f35b6000610094338484610121565b50505050565b50565b600082600082815260200190815260200160002060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050929150505600a26469706673582212206a",
-  "deployedBytecode": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c8063a9059cbb1461003b578063dd62ed3e14610057575b600080fd5b61005560048036038101906100509190610123565b610087565b005b610071600480360381019061006c9190610163565b6100a1565b60405161007e91906101b2565b60405180910390f35b6000610094338484610121565b50505050565b50565b600082600082815260200190815260200160002060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050929150505600a26469706673582212206a"
-} 

package/src/lib/parsers/artifact/__tests__/fixtures/wrong-types.json

@@ -1,7 +0,0 @@
-{
-  "contractName": 123,
-  "abi": "not-an-array",
-  "bytecode": {
-    "object": "0x608060405234801561001057600080fd5b50"
-  }
-} 

package/src/lib/parsers/artifact/foundry-1.2.ts

@@ -1,72 +0,0 @@
-import { ArtifactParser } from './types'
-import { Artifact } from '../../types'
-import * as path from 'path'
-
-/**
- * A parser for Foundry 1.2+ artifact format.
- * Can handle artifacts with or without explicit "contractName" field.
- * If no contractName is present, it attempts to extract it from:
- * 1. metadata.settings.compilationTarget
- * 2. The filename as a fallback
- */
-export const foundry12Parser: ArtifactParser = (content: string, filePath: string): Omit<Artifact, '_path' | '_hash'> | null => {
-  try {
-    const json = JSON.parse(content)
-
-    // Basic validation to see if it matches our expected structure
-    if (
-      typeof json === 'object' &&
-      json !== null &&
-      Array.isArray(json.abi) &&
-      (typeof json.bytecode === 'string' || (typeof json.bytecode === 'object' && typeof json.bytecode.object === 'string'))
-    ) {
-      // Handle Hardhat-style bytecode object vs. simple string
-      const bytecode = typeof json.bytecode === 'object' ? json.bytecode.object : json.bytecode
-      if (!bytecode || !bytecode.startsWith('0x')) {
-        return null // Bytecode must be a hex string
-      }
-      
-      const deployedBytecode = typeof json.deployedBytecode === 'object' ? json.deployedBytecode?.object : json.deployedBytecode
-
-      // Extract contract name from various sources
-      let contractName = json.contractName
-
-      // If no explicit contractName, prefer filename over metadata to match file-based lookups
-      if (!contractName && filePath) {
-        const basename = path.basename(filePath, '.json')
-        contractName = basename
-      }
-
-      // If still no contract name, try to extract from metadata as fallback
-      if (!contractName && json.metadata?.settings?.compilationTarget) {
-        const compilationTarget = json.metadata.settings.compilationTarget
-        // compilationTarget is like {"src/Counter.sol": "Counter"}
-        const contractNames = Object.values(compilationTarget)
-        if (contractNames.length > 0) {
-          contractName = contractNames[0]
-        }
-      }
-
-      // Must have a contract name to proceed
-      if (!contractName) {
-        return null
-      }
-
-      // We have a likely match
-      return {
-        contractName: contractName,
-        sourceName: json.sourceName,
-        abi: json.abi,
-        bytecode: bytecode,
-        deployedBytecode: deployedBytecode,
-        compiler: json.compiler,
-        source: json.source,
-      }
-    }
-
-    return null
-  } catch (error) {
-    // Not valid JSON, so it's not for this parser
-    return null
-  }
-}

package/src/lib/parsers/artifact/index.ts

@@ -1,27 +0,0 @@
-import { ArtifactParser } from './types'
-import { foundry12Parser } from './foundry-1.2'
-import { Artifact } from '../../types'
-
-// Array of all available artifact parsers.
-// To add a new format, create a new parser and add it to this list.
-const parsers: ArtifactParser[] = [
-  foundry12Parser,
-  // Future parsers (e.g., truffleParser) would go here.
-]
-
-/**
- * Attempts to parse a file's content using a series of registered parsers.
- * Returns the first successfully parsed Artifact.
- * @param content The raw string content of the file.
- * @param filePath The path to the file being parsed.
- * @returns A parsed Artifact object or null if no parser succeeds.
- */
-export function parseArtifact(content: string, filePath: string): Omit<Artifact, '_path' | '_hash'> | null {
-  for (const parser of parsers) {
-    const result = parser(content, filePath)
-    if (result) {
-      return result
-    }
-  }
-  return null
-}

package/src/lib/parsers/artifact/types.ts

@@ -1,9 +0,0 @@
-import { Artifact } from '../../types'
-
-/**
- * A function that attempts to parse a file's content into a standard Artifact object.
- * @param content The raw string content of the file.
- * @param filePath The path to the file being parsed.
- * @returns An object conforming to the Artifact interface (without internal properties), or null if parsing fails.
- */
-export type ArtifactParser = (content: string, filePath: string) => Omit<Artifact, '_path' | '_hash'> | null

package/src/lib/parsers/buildinfo.ts

@@ -1,127 +0,0 @@
-import { createHash } from 'crypto'
-import { keccak256, toUtf8Bytes } from 'ethers'
-import { BuildInfo, ExtractedContract } from '../types'
-
-/**
- * Validates if a parsed object is a valid build-info file
- * Supports standard build-info formats and factory-style formats
- */
-function isValidBuildInfo(data: any): data is BuildInfo {
-  return (
-    data &&
-    typeof data === 'object' &&
-    // _format field is optional (for factory-style formats)
-    (data._format === undefined || data._format === 'hh-sol-build-info-1' || data._format === 'ethers-rs-sol-build-info-1') &&
-    typeof data.id === 'string' &&
-    typeof data.solcVersion === 'string' &&
-    // solcLongVersion is optional (for factory-style formats)
-    (data.solcLongVersion === undefined || typeof data.solcLongVersion === 'string') &&
-    data.input &&
-    typeof data.input === 'object' &&
-    data.output &&
-    typeof data.output === 'object' &&
-    data.output.contracts &&
-    typeof data.output.contracts === 'object'
-  )
-}
-
-/**
- * Parses a build-info file and extracts individual contracts
- * @param content The raw string content of the build-info file
- * @param filePath The path to the build-info file
- * @returns Array of extracted contracts or null if parsing fails
- */
-export function parseBuildInfo(content: string, filePath: string): ExtractedContract[] | null {
-  try {
-    const data = JSON.parse(content)
-    
-    if (!isValidBuildInfo(data)) {
-      return null
-    }
-
-    const extractedContracts: ExtractedContract[] = []
-    
-    // Extract contracts from output.contracts
-    for (const [sourceName, sourceContracts] of Object.entries(data.output.contracts)) {
-      for (const [contractName, contractData] of Object.entries(sourceContracts)) {
-        // Validate contract data
-        if (!contractData.abi || !Array.isArray(contractData.abi)) {
-          continue
-        }
-        
-        // Handle both Hardhat format (with 0x prefix) and ethers-rs format (without 0x prefix)
-        if (!contractData.evm?.bytecode?.object || 
-            (!contractData.evm.bytecode.object.startsWith('0x') && !/^[0-9a-fA-F]+$/.test(contractData.evm.bytecode.object))) {
-          continue
-        }
-        
-        // Get source content if available
-        const sourceContent = data.input.sources[sourceName]?.content
-        
-        // Normalize bytecode to ensure it has 0x prefix (required by the rest of the system)
-        const bytecode = contractData.evm.bytecode.object.startsWith('0x') 
-          ? contractData.evm.bytecode.object 
-          : '0x' + contractData.evm.bytecode.object
-        
-        const deployedBytecode = contractData.evm.deployedBytecode?.object
-          ? (contractData.evm.deployedBytecode.object.startsWith('0x')
-            ? contractData.evm.deployedBytecode.object
-            : '0x' + contractData.evm.deployedBytecode.object)
-          : undefined
-
-        // Create the extracted contract
-        const extractedContract: ExtractedContract = {
-          contractName,
-          sourceName,
-          fullyQualifiedName: `${sourceName}:${contractName}`,
-          abi: contractData.abi,
-          bytecode,
-          deployedBytecode,
-          source: sourceContent,
-          compiler: {
-            // Use solcLongVersion if available, otherwise fallback to solcVersion
-            version: data.solcLongVersion || data.solcVersion
-          },
-          buildInfoId: data.id,
-          buildInfoPath: filePath
-        }
-        
-        extractedContracts.push(extractedContract)
-      }
-    }
-    
-    return extractedContracts.length > 0 ? extractedContracts : null
-    
-  } catch (error) {
-    // Not valid JSON or other parsing error
-    return null
-  }
-}
-
-/**
- * Checks if a file path looks like a build-info file
- * Follows the conventions: artifacts/build-info/*.json or out/build-info/*.json
- */
-export function isBuildInfoFile(filePath: string): boolean {
-  // Standard build-info file patterns
-  if (filePath.includes('/build-info/') && filePath.endsWith('.json')) {
-    return true
-  }
-
-  return false
-}
-
-/**
- * Converts an ExtractedContract to an Artifact-compatible format
- */
-export function extractedContractToArtifact(extracted: ExtractedContract): Omit<import('../types').Artifact, '_path' | '_hash'> {
-  return {
-    contractName: extracted.contractName,
-    abi: extracted.abi,
-    bytecode: extracted.bytecode,
-    deployedBytecode: extracted.deployedBytecode,
-    sourceName: extracted.sourceName,
-    source: extracted.source,
-    compiler: extracted.compiler
-  }
-} 

package/src/lib/parsers/constants.ts

@@ -1,56 +0,0 @@
-import { parse as parseYaml, YAMLParseError } from 'yaml'
-import { ConstantsDocument } from '../types'
-
-/**
- * Parses a YAML string defining a constants document into a structured ConstantsDocument.
- * Accepts files with `type: "constants"`, optional `name`, and required `constants` object.
- * Returns null if the YAML is not a constants document.
- */
-export function parseConstants(yamlContent: string): ConstantsDocument | null {
-  let rawObject: any
-  try {
-    rawObject = parseYaml(yamlContent)
-  } catch (e) {
-    if (e instanceof YAMLParseError) {
-      const line = (e as any).linePos?.[0]?.line ? ` at line ${(e as any).linePos[0].line}` : ''
-      throw new Error(`Failed to parse constants YAML: ${e.message}${line}.`)
-    }
-    throw e
-  }
-
-  if (!rawObject || typeof rawObject !== 'object') {
-    return null
-  }
-
-  if (rawObject.type !== 'constants') {
-    return null
-  }
-
-  if (rawObject.name !== undefined && typeof rawObject.name !== 'string') {
-    throw new Error('Invalid constants: "name" must be a string if provided.')
-  }
-
-  if (!rawObject.constants || typeof rawObject.constants !== 'object' || Array.isArray(rawObject.constants)) {
-    throw new Error('Invalid constants: "constants" field is required and must be an object.')
-  }
-
-  const doc: ConstantsDocument = {
-    type: 'constants',
-    name: rawObject.name,
-    constants: rawObject.constants
-  }
-
-  return doc
-}
-
-/**
- * Validates and extracts optional job-level constants from a parsed job raw object.
- * Throws if present but not an object.
- */
-export function extractJobConstants(rawJob: any, jobNameForErrors: string): Record<string, any> | undefined {
-  if (rawJob.constants === undefined) return undefined
-  if (typeof rawJob.constants !== 'object' || Array.isArray(rawJob.constants)) {
-    throw new Error(`Invalid job "${jobNameForErrors}": "constants" field must be an object if provided.`)
-  }
-  return rawJob.constants as Record<string, any>
-}

package/src/lib/parsers/index.ts

@@ -1,5 +0,0 @@
-// Export all parsers
-export * from './template'
-export * from './job'
-export * from './buildinfo'
-export * from './constants'

package/src/lib/parsers/job.ts

@@ -1,148 +0,0 @@
-import { parse as parseYaml, YAMLParseError } from 'yaml'
-import { Condition, Job, JobAction } from '../types'
-
-/**
- * Determines whether a raw YAML item is a valid Condition.
- * Mirrors the validation logic used for templates so job-level
- * skip conditions behave consistently.
- */
-function isCondition(item: any): item is Condition {
-  if (!item || typeof item !== 'object' || typeof item.type !== 'string') {
-    return false
-  }
-
-  if (['contract-exists', 'job-completed'].includes(item.type)) {
-    return true
-  }
-
-  if (item.type === 'basic-arithmetic') {
-    const op = item.arguments?.operation
-    return typeof op === 'string' && ['eq', 'neq', 'gt', 'lt', 'gte', 'lte'].includes(op)
-  }
-
-  return false
-}
-
-/**
- * Parses a YAML string defining a job into a structured `Job` object.
- * This function validates the presence and basic types of required fields
- * for both the job and its nested actions.
- *
- * @param yamlContent The raw YAML content of the job file as a string.
- * @returns The parsed and validated `Job` object.
- * @throws {Error} If the YAML is malformed or if the job is missing required fields.
- */
-export function parseJob(yamlContent: string): Job {
-  let rawObject: any
-  try {
-    rawObject = parseYaml(yamlContent)
-  } catch (e) {
-    if (e instanceof YAMLParseError) {
-      const line = e.linePos?.[0].line ? ` at line ${e.linePos[0].line}` : ''
-      throw new Error(`Failed to parse job YAML: ${e.message}${line}.`)
-    }
-    throw e
-  }
-
-  if (!rawObject || typeof rawObject !== 'object') {
-    throw new Error('Invalid job: YAML content must resolve to an object.')
-  }
-
-  // If a top-level discriminator exists and is not a job, bail out early with a helpful error
-  if (rawObject.type && rawObject.type !== 'job') {
-    throw new Error('Invalid job: unexpected type discriminator. Did you mean a template file with type: "template"?')
-  }
-
-  // --- Validate required top-level fields ---
-  if (!rawObject.name || typeof rawObject.name !== 'string') {
-    throw new Error('Invalid job: "name" field is required and must be a string.')
-  }
-  // The YAML parser may interpret a version like "1.0" as a number, so we ensure it's a string.
-  if (!rawObject.version) {
-    throw new Error(`Invalid job "${rawObject.name}": "version" field is required.`)
-  }
-  rawObject.version = String(rawObject.version)
-
-  if (!rawObject.actions || !Array.isArray(rawObject.actions)) {
-    throw new Error(`Invalid job "${rawObject.name}": "actions" field is required and must be an array.`)
-  }
-
-  // --- Validate each action within the job ---
-  for (const action of rawObject.actions) {
-    if (!action || typeof action !== 'object') {
-      throw new Error(`Invalid job "${rawObject.name}": contains a non-object item in "actions" array.`)
-    }
-    if (!action.name || typeof action.name !== 'string') {
-      throw new Error(`Invalid job "${rawObject.name}": an action is missing the required "name" field.`)
-    }
-    
-    // Validate that the action has either a template or type field, but not both
-    const hasTemplate = action.template && typeof action.template === 'string'
-    const hasType = action.type && typeof action.type === 'string'
-    
-    if (!hasTemplate && !hasType) {
-      throw new Error(`Invalid job "${rawObject.name}": action "${action.name}" must have either a "template" field (for template actions) or a "type" field (for primitive actions).`)
-    }
-    if (hasTemplate && hasType) {
-      throw new Error(`Invalid job "${rawObject.name}": action "${action.name}" cannot have both "template" and "type" fields. Use only one.`)
-    }
-    
-    if (!action.arguments || typeof action.arguments !== 'object' || Array.isArray(action.arguments)) {
-      throw new Error(`Invalid job "${rawObject.name}": action "${action.name}" is missing the required "arguments" field or it is not an object.`)
-    }
-    
-    // Validate the optional output field
-    if (action.output !== undefined) {
-      const t = typeof action.output
-      const isObject = t === 'object' && action.output !== null && !Array.isArray(action.output)
-      if (t !== 'boolean' && !isObject) {
-        throw new Error(`Invalid job "${rawObject.name}": action "${action.name}" has an invalid "output" field. It must be either a boolean (true/false) or an object mapping custom outputs.`)
-      }
-    }
-  }
-
-  // --- Optional: validate deprecated flag if present ---
-  if (rawObject.deprecated !== undefined && typeof rawObject.deprecated !== 'boolean') {
-    throw new Error(`Invalid job "${rawObject.name}": "deprecated" must be a boolean if provided.`)
-  }
-  // --- Optional: validate min_evm_version if present ---
-  if (rawObject.min_evm_version !== undefined && typeof rawObject.min_evm_version !== 'string') {
-    throw new Error(`Invalid job "${rawObject.name}": "min_evm_version" must be a string if provided.`)
-  }
-
-  // --- Optional: validate job-level skip_condition and constants ---
-  if (rawObject.skip_condition !== undefined) {
-    if (!Array.isArray(rawObject.skip_condition)) {
-      throw new Error(`Invalid job "${rawObject.name}": "skip_condition" must be an array if provided.`)
-    }
-    for (const condition of rawObject.skip_condition) {
-      if (!isCondition(condition)) {
-        throw new Error(`Invalid job "${rawObject.name}": "skip_condition" contains an invalid condition entry.`)
-      }
-    }
-  }
-
-  if (rawObject.constants !== undefined) {
-    if (typeof rawObject.constants !== 'object' || rawObject.constants === null || Array.isArray(rawObject.constants)) {
-      throw new Error(`Invalid job "${rawObject.name}": "constants" field must be an object if provided.`)
-    }
-  }
-
-  // --- Construct and return the strongly-typed Job object ---
-  const job: Job = {
-    name: rawObject.name,
-    version: rawObject.version,
-    description: rawObject.description,
-    depends_on: rawObject.depends_on,
-    // We've validated the necessary parts, so a cast is reasonable here.
-    actions: rawObject.actions as JobAction[],
-    only_networks: rawObject.only_networks,
-    skip_networks: rawObject.skip_networks,
-    min_evm_version: rawObject.min_evm_version,
-    deprecated: rawObject.deprecated === true,
-    skip_condition: rawObject.skip_condition as Condition[] | undefined,
-    constants: rawObject.constants,
-  }
-
-  return job
-}

package/src/lib/parsers/template.ts

@@ -1,135 +0,0 @@
-import { parse as parseYaml, YAMLParseError } from 'yaml'
-import { Template, Action, Condition, Value } from '../types'
-
-/**
- * Helper to check if a parsed YAML object represents a Condition.
- * Conditions are specific checks that resolve to a boolean, used in `skip_condition` blocks.
- * @param item The parsed object from YAML.
- * @returns True if the item is a Condition, false otherwise.
- */
-function isCondition(item: any): item is Condition {
-  // A 'Condition' must be an object with a 'type' property.
-  if (!item || typeof item !== 'object' || typeof item.type !== 'string') {
-    return false
-  }
-
-  // Check against known, specific condition types from `src/lib/types/conditions.ts`.
-  if (['contract-exists', 'job-completed'].includes(item.type)) {
-    return true
-  }
-
-  if (item.type === 'value-empty') {
-    return !!(item.arguments && typeof item.arguments === 'object' && 'value' in item.arguments)
-  }
-
-  // The 'basic-arithmetic' ValueResolver can also act as a Condition
-  // if it performs a boolean comparison operation.
-  if (item.type === 'basic-arithmetic') {
-    if (item.arguments && typeof item.arguments.operation === 'string') {
-      const booleanOperations = ['eq', 'neq', 'gt', 'lt', 'gte', 'lte']
-      return booleanOperations.includes(item.arguments.operation)
-    }
-  }
-
-  return false
-}
-
-/**
- * Parses a YAML string defining an action template into a structured `Template` object.
- * This function handles validation and normalization of the template structure, including
- * the flexible `setup` block which can be an array of mixed actions/conditions or
- * a structured object.
- *
- * @param yamlContent The raw YAML content of the template file as a string.
- * @returns The parsed and validated `Template` object.
- * @throws {Error} If the YAML is malformed, or if the template is missing required fields
- *                 like `name`, `actions`, or `outputs`.
- */
-export function parseTemplate(yamlContent: string): Template {
-  let rawObject: any
-  try {
-    rawObject = parseYaml(yamlContent)
-  } catch (e) {
-    if (e instanceof YAMLParseError) {
-      // Provide a more user-friendly error message including the line number
-      const line = e.linePos?.[0].line ? ` at line ${e.linePos[0].line}` : ''
-      throw new Error(`Failed to parse template YAML: ${e.message}${line}.`)
-    }
-    throw e
-  }
-
-  if (!rawObject || typeof rawObject !== 'object') {
-    throw new Error('Invalid template: YAML content must resolve to an object.')
-  }
-
-  // If a discriminator is provided, ensure it matches
-  if (rawObject.type !== undefined && rawObject.type !== 'template') {
-    throw new Error('Invalid template: expected type to be "template" if provided.')
-  }
-
-  // --- Validate required fields ---
-  if (!rawObject.name || typeof rawObject.name !== 'string') {
-    throw new Error('Invalid template: "name" field is required and must be a string.')
-  }
-  if (!rawObject.actions || !Array.isArray(rawObject.actions)) {
-    throw new Error(`Invalid template "${rawObject.name}": "actions" field is required and must be an array.`)
-  }
-  
-  // Allow 'outputs' to be optional. If it exists, it must be an object.
-  if (rawObject.outputs && (typeof rawObject.outputs !== 'object' || Array.isArray(rawObject.outputs))) {
-    throw new Error(`Invalid template "${rawObject.name}": "outputs" field must be an object if provided.`)
-  }
-
-  // --- Construct the base template object ---
-  const template: Template = {
-    type: 'template',
-    name: rawObject.name,
-    description: rawObject.description,
-    arguments: rawObject.arguments,
-    returns: rawObject.returns,
-    actions: rawObject.actions as Action[],
-    skip_condition: rawObject.skip_condition as Condition[],
-  }
-
-  // Only include outputs if it was provided in the YAML
-  if (rawObject.outputs) {
-    template.outputs = rawObject.outputs as Record<string, Value<any>>
-  }
-
-  // --- Handle the 'setup' block which can have multiple formats ---
-  if (rawObject.setup) {
-    if (Array.isArray(rawObject.setup)) {
-      // Format 1: An array of mixed actions and conditions (e.g., sequence-factory-v1.yaml).
-      // We need to iterate and categorize each item.
-      const setupActions: Action[] = []
-      const setupConditions: Condition[] = []
-
-      for (const item of rawObject.setup) {
-        if (isCondition(item)) {
-          setupConditions.push(item)
-        } else {
-          // If it's not an explicit condition, we assume it's an action.
-          setupActions.push(item as Action)
-        }
-      }
-
-      template.setup = {}
-      if (setupActions.length > 0) {
-        template.setup.actions = setupActions
-      }
-      if (setupConditions.length > 0) {
-        template.setup.skip_condition = setupConditions
-      }
-    } else if (typeof rawObject.setup === 'object') {
-      // Format 2: A structured object (e.g., nano-universal-deployer.yaml), which maps directly to our type.
-      template.setup = {
-        actions: (rawObject.setup.actions || []) as Action[],
-        skip_condition: (rawObject.setup.skip_condition || []) as Condition[],
-      }
-    } else {
-      throw new Error(`Invalid template "${rawObject.name}": "setup" field must be an array or an object if provided.`)
-    }
-  }
-
-  return template
-}